dvadf
File manager - Edit - /home/centroca/public_html/Gmail.tar
Back
WatchRequest.php 0000644 00000004370 15253110636 0007702 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class WatchRequest extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'labelIds'; /** * @var string */ public $labelFilterAction; /** * @var string */ public $labelFilterBehavior; /** * @var string[] */ public $labelIds; /** * @var string */ public $topicName; /** * @param string */ public function setLabelFilterAction($labelFilterAction) { $this->labelFilterAction = $labelFilterAction; } /** * @return string */ public function getLabelFilterAction() { return $this->labelFilterAction; } /** * @param string */ public function setLabelFilterBehavior($labelFilterBehavior) { $this->labelFilterBehavior = $labelFilterBehavior; } /** * @return string */ public function getLabelFilterBehavior() { return $this->labelFilterBehavior; } /** * @param string[] */ public function setLabelIds($labelIds) { $this->labelIds = $labelIds; } /** * @return string[] */ public function getLabelIds() { return $this->labelIds; } /** * @param string */ public function setTopicName($topicName) { $this->topicName = $topicName; } /** * @return string */ public function getTopicName() { return $this->topicName; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(WatchRequest::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_WatchRequest'); ListFiltersResponse.php 0000644 00000002373 15253110636 0011247 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ListFiltersResponse extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'filter'; protected $filterType = Filter::class; protected $filterDataType = 'array'; /** * @param Filter[] */ public function setFilter($filter) { $this->filter = $filter; } /** * @return Filter[] */ public function getFilter() { return $this->filter; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ListFiltersResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ListFiltersResponse'); Message.php 0000644 00000007113 15253110636 0006645 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class Message extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'labelIds'; /** * @var string */ public $historyId; /** * @var string */ public $id; /** * @var string */ public $internalDate; /** * @var string[] */ public $labelIds; protected $payloadType = MessagePart::class; protected $payloadDataType = ''; /** * @var string */ public $raw; /** * @var int */ public $sizeEstimate; /** * @var string */ public $snippet; /** * @var string */ public $threadId; /** * @param string */ public function setHistoryId($historyId) { $this->historyId = $historyId; } /** * @return string */ public function getHistoryId() { return $this->historyId; } /** * @param string */ public function setId($id) { $this->id = $id; } /** * @return string */ public function getId() { return $this->id; } /** * @param string */ public function setInternalDate($internalDate) { $this->internalDate = $internalDate; } /** * @return string */ public function getInternalDate() { return $this->internalDate; } /** * @param string[] */ public function setLabelIds($labelIds) { $this->labelIds = $labelIds; } /** * @return string[] */ public function getLabelIds() { return $this->labelIds; } /** * @param MessagePart */ public function setPayload(MessagePart $payload) { $this->payload = $payload; } /** * @return MessagePart */ public function getPayload() { return $this->payload; } /** * @param string */ public function setRaw($raw) { $this->raw = $raw; } /** * @return string */ public function getRaw() { return $this->raw; } /** * @param int */ public function setSizeEstimate($sizeEstimate) { $this->sizeEstimate = $sizeEstimate; } /** * @return int */ public function getSizeEstimate() { return $this->sizeEstimate; } /** * @param string */ public function setSnippet($snippet) { $this->snippet = $snippet; } /** * @return string */ public function getSnippet() { return $this->snippet; } /** * @param string */ public function setThreadId($threadId) { $this->threadId = $threadId; } /** * @return string */ public function getThreadId() { return $this->threadId; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(Message::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Message'); MessagePartBody.php 0000644 00000003344 15253110636 0010314 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class MessagePartBody extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $attachmentId; /** * @var string */ public $data; /** * @var int */ public $size; /** * @param string */ public function setAttachmentId($attachmentId) { $this->attachmentId = $attachmentId; } /** * @return string */ public function getAttachmentId() { return $this->attachmentId; } /** * @param string */ public function setData($data) { $this->data = $data; } /** * @return string */ public function getData() { return $this->data; } /** * @param int */ public function setSize($size) { $this->size = $size; } /** * @return int */ public function getSize() { return $this->size; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(MessagePartBody::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_MessagePartBody'); FilterCriteria.php 0000644 00000007014 15253110636 0010171 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class FilterCriteria extends \WPMailSMTP\Vendor\Google\Model { /** * @var bool */ public $excludeChats; /** * @var string */ public $from; /** * @var bool */ public $hasAttachment; /** * @var string */ public $negatedQuery; /** * @var string */ public $query; /** * @var int */ public $size; /** * @var string */ public $sizeComparison; /** * @var string */ public $subject; /** * @var string */ public $to; /** * @param bool */ public function setExcludeChats($excludeChats) { $this->excludeChats = $excludeChats; } /** * @return bool */ public function getExcludeChats() { return $this->excludeChats; } /** * @param string */ public function setFrom($from) { $this->from = $from; } /** * @return string */ public function getFrom() { return $this->from; } /** * @param bool */ public function setHasAttachment($hasAttachment) { $this->hasAttachment = $hasAttachment; } /** * @return bool */ public function getHasAttachment() { return $this->hasAttachment; } /** * @param string */ public function setNegatedQuery($negatedQuery) { $this->negatedQuery = $negatedQuery; } /** * @return string */ public function getNegatedQuery() { return $this->negatedQuery; } /** * @param string */ public function setQuery($query) { $this->query = $query; } /** * @return string */ public function getQuery() { return $this->query; } /** * @param int */ public function setSize($size) { $this->size = $size; } /** * @return int */ public function getSize() { return $this->size; } /** * @param string */ public function setSizeComparison($sizeComparison) { $this->sizeComparison = $sizeComparison; } /** * @return string */ public function getSizeComparison() { return $this->sizeComparison; } /** * @param string */ public function setSubject($subject) { $this->subject = $subject; } /** * @return string */ public function getSubject() { return $this->subject; } /** * @param string */ public function setTo($to) { $this->to = $to; } /** * @return string */ public function getTo() { return $this->to; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(FilterCriteria::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_FilterCriteria'); SmimeInfo.php 0000644 00000005667 15253110636 0007163 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class SmimeInfo extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $encryptedKeyPassword; /** * @var string */ public $expiration; /** * @var string */ public $id; /** * @var bool */ public $isDefault; /** * @var string */ public $issuerCn; /** * @var string */ public $pem; /** * @var string */ public $pkcs12; /** * @param string */ public function setEncryptedKeyPassword($encryptedKeyPassword) { $this->encryptedKeyPassword = $encryptedKeyPassword; } /** * @return string */ public function getEncryptedKeyPassword() { return $this->encryptedKeyPassword; } /** * @param string */ public function setExpiration($expiration) { $this->expiration = $expiration; } /** * @return string */ public function getExpiration() { return $this->expiration; } /** * @param string */ public function setId($id) { $this->id = $id; } /** * @return string */ public function getId() { return $this->id; } /** * @param bool */ public function setIsDefault($isDefault) { $this->isDefault = $isDefault; } /** * @return bool */ public function getIsDefault() { return $this->isDefault; } /** * @param string */ public function setIssuerCn($issuerCn) { $this->issuerCn = $issuerCn; } /** * @return string */ public function getIssuerCn() { return $this->issuerCn; } /** * @param string */ public function setPem($pem) { $this->pem = $pem; } /** * @return string */ public function getPem() { return $this->pem; } /** * @param string */ public function setPkcs12($pkcs12) { $this->pkcs12 = $pkcs12; } /** * @return string */ public function getPkcs12() { return $this->pkcs12; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(SmimeInfo::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_SmimeInfo'); ListLabelsResponse.php 0000644 00000002365 15253110636 0011042 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ListLabelsResponse extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'labels'; protected $labelsType = Label::class; protected $labelsDataType = 'array'; /** * @param Label[] */ public function setLabels($labels) { $this->labels = $labels; } /** * @return Label[] */ public function getLabels() { return $this->labels; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ListLabelsResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ListLabelsResponse'); ListDraftsResponse.php 0000644 00000003672 15253110636 0011065 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ListDraftsResponse extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'drafts'; protected $draftsType = Draft::class; protected $draftsDataType = 'array'; /** * @var string */ public $nextPageToken; /** * @var string */ public $resultSizeEstimate; /** * @param Draft[] */ public function setDrafts($drafts) { $this->drafts = $drafts; } /** * @return Draft[] */ public function getDrafts() { return $this->drafts; } /** * @param string */ public function setNextPageToken($nextPageToken) { $this->nextPageToken = $nextPageToken; } /** * @return string */ public function getNextPageToken() { return $this->nextPageToken; } /** * @param string */ public function setResultSizeEstimate($resultSizeEstimate) { $this->resultSizeEstimate = $resultSizeEstimate; } /** * @return string */ public function getResultSizeEstimate() { return $this->resultSizeEstimate; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ListDraftsResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ListDraftsResponse'); HistoryMessageDeleted.php 0000644 00000002334 15253110636 0011516 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class HistoryMessageDeleted extends \WPMailSMTP\Vendor\Google\Model { protected $messageType = Message::class; protected $messageDataType = ''; /** * @param Message */ public function setMessage(Message $message) { $this->message = $message; } /** * @return Message */ public function getMessage() { return $this->message; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(HistoryMessageDeleted::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_HistoryMessageDeleted'); DisableCseKeyPairRequest.php 0000644 00000001632 15253110636 0012115 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class DisableCseKeyPairRequest extends \WPMailSMTP\Vendor\Google\Model { } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(DisableCseKeyPairRequest::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_DisableCseKeyPairRequest'); HistoryLabelAdded.php 0000644 00000003065 15253110636 0010606 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class HistoryLabelAdded extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'labelIds'; /** * @var string[] */ public $labelIds; protected $messageType = Message::class; protected $messageDataType = ''; /** * @param string[] */ public function setLabelIds($labelIds) { $this->labelIds = $labelIds; } /** * @return string[] */ public function getLabelIds() { return $this->labelIds; } /** * @param Message */ public function setMessage(Message $message) { $this->message = $message; } /** * @return Message */ public function getMessage() { return $this->message; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(HistoryLabelAdded::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_HistoryLabelAdded'); History.php 0000644 00000006167 15253110636 0006732 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class History extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'messagesDeleted'; /** * @var string */ public $id; protected $labelsAddedType = HistoryLabelAdded::class; protected $labelsAddedDataType = 'array'; protected $labelsRemovedType = HistoryLabelRemoved::class; protected $labelsRemovedDataType = 'array'; protected $messagesType = Message::class; protected $messagesDataType = 'array'; protected $messagesAddedType = HistoryMessageAdded::class; protected $messagesAddedDataType = 'array'; protected $messagesDeletedType = HistoryMessageDeleted::class; protected $messagesDeletedDataType = 'array'; /** * @param string */ public function setId($id) { $this->id = $id; } /** * @return string */ public function getId() { return $this->id; } /** * @param HistoryLabelAdded[] */ public function setLabelsAdded($labelsAdded) { $this->labelsAdded = $labelsAdded; } /** * @return HistoryLabelAdded[] */ public function getLabelsAdded() { return $this->labelsAdded; } /** * @param HistoryLabelRemoved[] */ public function setLabelsRemoved($labelsRemoved) { $this->labelsRemoved = $labelsRemoved; } /** * @return HistoryLabelRemoved[] */ public function getLabelsRemoved() { return $this->labelsRemoved; } /** * @param Message[] */ public function setMessages($messages) { $this->messages = $messages; } /** * @return Message[] */ public function getMessages() { return $this->messages; } /** * @param HistoryMessageAdded[] */ public function setMessagesAdded($messagesAdded) { $this->messagesAdded = $messagesAdded; } /** * @return HistoryMessageAdded[] */ public function getMessagesAdded() { return $this->messagesAdded; } /** * @param HistoryMessageDeleted[] */ public function setMessagesDeleted($messagesDeleted) { $this->messagesDeleted = $messagesDeleted; } /** * @return HistoryMessageDeleted[] */ public function getMessagesDeleted() { return $this->messagesDeleted; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(History::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_History'); ListHistoryResponse.php 0000644 00000003615 15253110636 0011300 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ListHistoryResponse extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'history'; protected $historyType = History::class; protected $historyDataType = 'array'; /** * @var string */ public $historyId; /** * @var string */ public $nextPageToken; /** * @param History[] */ public function setHistory($history) { $this->history = $history; } /** * @return History[] */ public function getHistory() { return $this->history; } /** * @param string */ public function setHistoryId($historyId) { $this->historyId = $historyId; } /** * @return string */ public function getHistoryId() { return $this->historyId; } /** * @param string */ public function setNextPageToken($nextPageToken) { $this->nextPageToken = $nextPageToken; } /** * @return string */ public function getNextPageToken() { return $this->nextPageToken; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ListHistoryResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ListHistoryResponse'); Resource/UsersSettingsCse.php 0000644 00000002132 15253110636 0012321 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; /** * The "cse" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $cse = $gmailService->users_settings_cse; * </code> */ class UsersSettingsCse extends \WPMailSMTP\Vendor\Google\Service\Resource { } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersSettingsCse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersSettingsCse'); Resource/UsersSettingsForwardingAddresses.php 0000644 00000011051 15253110636 0015547 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\ForwardingAddress; use WPMailSMTP\Vendor\Google\Service\Gmail\ListForwardingAddressesResponse; /** * The "forwardingAddresses" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $forwardingAddresses = $gmailService->users_settings_forwardingAddresses; * </code> */ class UsersSettingsForwardingAddresses extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Creates a forwarding address. If ownership verification is required, a * message will be sent to the recipient and the resource's verification status * will be set to `pending`; otherwise, the resource will be created with * verification status set to `accepted`. This method is only available to * service account clients that have been delegated domain-wide authority. * (forwardingAddresses.create) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param ForwardingAddress $postBody * @param array $optParams Optional parameters. * @return ForwardingAddress * @throws \Google\Service\Exception */ public function create($userId, ForwardingAddress $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('create', [$params], ForwardingAddress::class); } /** * Deletes the specified forwarding address and revokes any verification that * may have been required. This method is only available to service account * clients that have been delegated domain-wide authority. * (forwardingAddresses.delete) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param string $forwardingEmail The forwarding address to be deleted. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function delete($userId, $forwardingEmail, $optParams = []) { $params = ['userId' => $userId, 'forwardingEmail' => $forwardingEmail]; $params = \array_merge($params, $optParams); return $this->call('delete', [$params]); } /** * Gets the specified forwarding address. (forwardingAddresses.get) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param string $forwardingEmail The forwarding address to be retrieved. * @param array $optParams Optional parameters. * @return ForwardingAddress * @throws \Google\Service\Exception */ public function get($userId, $forwardingEmail, $optParams = []) { $params = ['userId' => $userId, 'forwardingEmail' => $forwardingEmail]; $params = \array_merge($params, $optParams); return $this->call('get', [$params], ForwardingAddress::class); } /** * Lists the forwarding addresses for the specified account. * (forwardingAddresses.listUsersSettingsForwardingAddresses) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * @return ListForwardingAddressesResponse * @throws \Google\Service\Exception */ public function listUsersSettingsForwardingAddresses($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('list', [$params], ListForwardingAddressesResponse::class); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersSettingsForwardingAddresses::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersSettingsForwardingAddresses'); Resource/UsersLabels.php 0000644 00000011735 15253110636 0011301 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\Label; use WPMailSMTP\Vendor\Google\Service\Gmail\ListLabelsResponse; /** * The "labels" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $labels = $gmailService->users_labels; * </code> */ class UsersLabels extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Creates a new label. (labels.create) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param Label $postBody * @param array $optParams Optional parameters. * @return Label * @throws \Google\Service\Exception */ public function create($userId, Label $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('create', [$params], Label::class); } /** * Immediately and permanently deletes the specified label and removes it from * any messages and threads that it is applied to. (labels.delete) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the label to delete. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function delete($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('delete', [$params]); } /** * Gets the specified label. (labels.get) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the label to retrieve. * @param array $optParams Optional parameters. * @return Label * @throws \Google\Service\Exception */ public function get($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('get', [$params], Label::class); } /** * Lists all labels in the user's mailbox. (labels.listUsersLabels) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * @return ListLabelsResponse * @throws \Google\Service\Exception */ public function listUsersLabels($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('list', [$params], ListLabelsResponse::class); } /** * Patch the specified label. (labels.patch) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the label to update. * @param Label $postBody * @param array $optParams Optional parameters. * @return Label * @throws \Google\Service\Exception */ public function patch($userId, $id, Label $postBody, $optParams = []) { $params = ['userId' => $userId, 'id' => $id, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('patch', [$params], Label::class); } /** * Updates the specified label. (labels.update) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the label to update. * @param Label $postBody * @param array $optParams Optional parameters. * @return Label * @throws \Google\Service\Exception */ public function update($userId, $id, Label $postBody, $optParams = []) { $params = ['userId' => $userId, 'id' => $id, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('update', [$params], Label::class); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersLabels::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersLabels'); Resource/Users.php 0000644 00000006013 15253110636 0010147 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\Profile; use WPMailSMTP\Vendor\Google\Service\Gmail\WatchRequest; use WPMailSMTP\Vendor\Google\Service\Gmail\WatchResponse; /** * The "users" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $users = $gmailService->users; * </code> */ class Users extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Gets the current user's Gmail profile. (users.getProfile) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * * @opt_param bool temporaryEeccBypass * @return Profile * @throws \Google\Service\Exception */ public function getProfile($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('getProfile', [$params], Profile::class); } /** * Stop receiving push notifications for the given user mailbox. (users.stop) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function stop($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('stop', [$params]); } /** * Set up or update a push notification watch on the given user mailbox. * (users.watch) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param WatchRequest $postBody * @param array $optParams Optional parameters. * @return WatchResponse * @throws \Google\Service\Exception */ public function watch($userId, WatchRequest $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('watch', [$params], WatchResponse::class); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(Users::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_Users'); Resource/UsersSettingsSendAs.php 0000644 00000016275 15253110636 0013001 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\ListSendAsResponse; use WPMailSMTP\Vendor\Google\Service\Gmail\SendAs; /** * The "sendAs" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $sendAs = $gmailService->users_settings_sendAs; * </code> */ class UsersSettingsSendAs extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Creates a custom "from" send-as alias. If an SMTP MSA is specified, Gmail * will attempt to connect to the SMTP service to validate the configuration * before creating the alias. If ownership verification is required for the * alias, a message will be sent to the email address and the resource's * verification status will be set to `pending`; otherwise, the resource will be * created with verification status set to `accepted`. If a signature is * provided, Gmail will sanitize the HTML before saving it with the alias. This * method is only available to service account clients that have been delegated * domain-wide authority. (sendAs.create) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param SendAs $postBody * @param array $optParams Optional parameters. * @return SendAs * @throws \Google\Service\Exception */ public function create($userId, SendAs $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('create', [$params], SendAs::class); } /** * Deletes the specified send-as alias. Revokes any verification that may have * been required for using it. This method is only available to service account * clients that have been delegated domain-wide authority. (sendAs.delete) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param string $sendAsEmail The send-as alias to be deleted. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function delete($userId, $sendAsEmail, $optParams = []) { $params = ['userId' => $userId, 'sendAsEmail' => $sendAsEmail]; $params = \array_merge($params, $optParams); return $this->call('delete', [$params]); } /** * Gets the specified send-as alias. Fails with an HTTP 404 error if the * specified address is not a member of the collection. (sendAs.get) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param string $sendAsEmail The send-as alias to be retrieved. * @param array $optParams Optional parameters. * @return SendAs * @throws \Google\Service\Exception */ public function get($userId, $sendAsEmail, $optParams = []) { $params = ['userId' => $userId, 'sendAsEmail' => $sendAsEmail]; $params = \array_merge($params, $optParams); return $this->call('get', [$params], SendAs::class); } /** * Lists the send-as aliases for the specified account. The result includes the * primary send-as address associated with the account as well as any custom * "from" aliases. (sendAs.listUsersSettingsSendAs) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * @return ListSendAsResponse * @throws \Google\Service\Exception */ public function listUsersSettingsSendAs($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('list', [$params], ListSendAsResponse::class); } /** * Patch the specified send-as alias. (sendAs.patch) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param string $sendAsEmail The send-as alias to be updated. * @param SendAs $postBody * @param array $optParams Optional parameters. * @return SendAs * @throws \Google\Service\Exception */ public function patch($userId, $sendAsEmail, SendAs $postBody, $optParams = []) { $params = ['userId' => $userId, 'sendAsEmail' => $sendAsEmail, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('patch', [$params], SendAs::class); } /** * Updates a send-as alias. If a signature is provided, Gmail will sanitize the * HTML before saving it with the alias. Addresses other than the primary * address for the account can only be updated by service account clients that * have been delegated domain-wide authority. (sendAs.update) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param string $sendAsEmail The send-as alias to be updated. * @param SendAs $postBody * @param array $optParams Optional parameters. * @return SendAs * @throws \Google\Service\Exception */ public function update($userId, $sendAsEmail, SendAs $postBody, $optParams = []) { $params = ['userId' => $userId, 'sendAsEmail' => $sendAsEmail, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('update', [$params], SendAs::class); } /** * Sends a verification email to the specified send-as alias address. The * verification status must be `pending`. This method is only available to * service account clients that have been delegated domain-wide authority. * (sendAs.verify) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param string $sendAsEmail The send-as alias to be verified. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function verify($userId, $sendAsEmail, $optParams = []) { $params = ['userId' => $userId, 'sendAsEmail' => $sendAsEmail]; $params = \array_merge($params, $optParams); return $this->call('verify', [$params]); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersSettingsSendAs::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersSettingsSendAs'); Resource/UsersSettingsFilters.php 0000644 00000007246 15253110636 0013232 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\Filter; use WPMailSMTP\Vendor\Google\Service\Gmail\ListFiltersResponse; /** * The "filters" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $filters = $gmailService->users_settings_filters; * </code> */ class UsersSettingsFilters extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Creates a filter. Note: you can only create a maximum of 1,000 filters. * (filters.create) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param Filter $postBody * @param array $optParams Optional parameters. * @return Filter * @throws \Google\Service\Exception */ public function create($userId, Filter $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('create', [$params], Filter::class); } /** * Immediately and permanently deletes the specified filter. (filters.delete) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param string $id The ID of the filter to be deleted. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function delete($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('delete', [$params]); } /** * Gets a filter. (filters.get) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param string $id The ID of the filter to be fetched. * @param array $optParams Optional parameters. * @return Filter * @throws \Google\Service\Exception */ public function get($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('get', [$params], Filter::class); } /** * Lists the message filters of a Gmail user. (filters.listUsersSettingsFilters) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * @return ListFiltersResponse * @throws \Google\Service\Exception */ public function listUsersSettingsFilters($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('list', [$params], ListFiltersResponse::class); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersSettingsFilters::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersSettingsFilters'); Resource/UsersDrafts.php 0000644 00000013226 15253110636 0011317 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\Draft; use WPMailSMTP\Vendor\Google\Service\Gmail\ListDraftsResponse; use WPMailSMTP\Vendor\Google\Service\Gmail\Message; /** * The "drafts" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $drafts = $gmailService->users_drafts; * </code> */ class UsersDrafts extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Creates a new draft with the `DRAFT` label. (drafts.create) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param Draft $postBody * @param array $optParams Optional parameters. * @return Draft * @throws \Google\Service\Exception */ public function create($userId, Draft $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('create', [$params], Draft::class); } /** * Immediately and permanently deletes the specified draft. Does not simply * trash it. (drafts.delete) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the draft to delete. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function delete($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('delete', [$params]); } /** * Gets the specified draft. (drafts.get) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the draft to retrieve. * @param array $optParams Optional parameters. * * @opt_param string format The format to return the draft in. * @return Draft * @throws \Google\Service\Exception */ public function get($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('get', [$params], Draft::class); } /** * Lists the drafts in the user's mailbox. (drafts.listUsersDrafts) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * * @opt_param bool includeSpamTrash Include drafts from `SPAM` and `TRASH` in * the results. * @opt_param string maxResults Maximum number of drafts to return. This field * defaults to 100. The maximum allowed value for this field is 500. * @opt_param string pageToken Page token to retrieve a specific page of results * in the list. * @opt_param string q Only return draft messages matching the specified query. * Supports the same query format as the Gmail search box. For example, * `"from:someuser@example.com rfc822msgid: is:unread"`. * @return ListDraftsResponse * @throws \Google\Service\Exception */ public function listUsersDrafts($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('list', [$params], ListDraftsResponse::class); } /** * Sends the specified, existing draft to the recipients in the `To`, `Cc`, and * `Bcc` headers. (drafts.send) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param Draft $postBody * @param array $optParams Optional parameters. * @return Message * @throws \Google\Service\Exception */ public function send($userId, Draft $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('send', [$params], Message::class); } /** * Replaces a draft's content. (drafts.update) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the draft to update. * @param Draft $postBody * @param array $optParams Optional parameters. * @return Draft * @throws \Google\Service\Exception */ public function update($userId, $id, Draft $postBody, $optParams = []) { $params = ['userId' => $userId, 'id' => $id, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('update', [$params], Draft::class); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersDrafts::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersDrafts'); Resource/UsersSettings.php 0000644 00000020055 15253110636 0011672 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\AutoForwarding; use WPMailSMTP\Vendor\Google\Service\Gmail\ImapSettings; use WPMailSMTP\Vendor\Google\Service\Gmail\LanguageSettings; use WPMailSMTP\Vendor\Google\Service\Gmail\PopSettings; use WPMailSMTP\Vendor\Google\Service\Gmail\VacationSettings; /** * The "settings" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $settings = $gmailService->users_settings; * </code> */ class UsersSettings extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Gets the auto-forwarding setting for the specified account. * (settings.getAutoForwarding) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * @return AutoForwarding * @throws \Google\Service\Exception */ public function getAutoForwarding($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('getAutoForwarding', [$params], AutoForwarding::class); } /** * Gets IMAP settings. (settings.getImap) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * @return ImapSettings * @throws \Google\Service\Exception */ public function getImap($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('getImap', [$params], ImapSettings::class); } /** * Gets language settings. (settings.getLanguage) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * @return LanguageSettings * @throws \Google\Service\Exception */ public function getLanguage($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('getLanguage', [$params], LanguageSettings::class); } /** * Gets POP settings. (settings.getPop) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * @return PopSettings * @throws \Google\Service\Exception */ public function getPop($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('getPop', [$params], PopSettings::class); } /** * Gets vacation responder settings. (settings.getVacation) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * @return VacationSettings * @throws \Google\Service\Exception */ public function getVacation($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('getVacation', [$params], VacationSettings::class); } /** * Updates the auto-forwarding setting for the specified account. A verified * forwarding address must be specified when auto-forwarding is enabled. This * method is only available to service account clients that have been delegated * domain-wide authority. (settings.updateAutoForwarding) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param AutoForwarding $postBody * @param array $optParams Optional parameters. * @return AutoForwarding * @throws \Google\Service\Exception */ public function updateAutoForwarding($userId, AutoForwarding $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('updateAutoForwarding', [$params], AutoForwarding::class); } /** * Updates IMAP settings. (settings.updateImap) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param ImapSettings $postBody * @param array $optParams Optional parameters. * @return ImapSettings * @throws \Google\Service\Exception */ public function updateImap($userId, ImapSettings $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('updateImap', [$params], ImapSettings::class); } /** * Updates language settings. If successful, the return object contains the * `displayLanguage` that was saved for the user, which may differ from the * value passed into the request. This is because the requested * `displayLanguage` may not be directly supported by Gmail but have a close * variant that is, and so the variant may be chosen and saved instead. * (settings.updateLanguage) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param LanguageSettings $postBody * @param array $optParams Optional parameters. * @return LanguageSettings * @throws \Google\Service\Exception */ public function updateLanguage($userId, LanguageSettings $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('updateLanguage', [$params], LanguageSettings::class); } /** * Updates POP settings. (settings.updatePop) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param PopSettings $postBody * @param array $optParams Optional parameters. * @return PopSettings * @throws \Google\Service\Exception */ public function updatePop($userId, PopSettings $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('updatePop', [$params], PopSettings::class); } /** * Updates vacation responder settings. (settings.updateVacation) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param VacationSettings $postBody * @param array $optParams Optional parameters. * @return VacationSettings * @throws \Google\Service\Exception */ public function updateVacation($userId, VacationSettings $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('updateVacation', [$params], VacationSettings::class); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersSettings::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersSettings'); Resource/UsersSettingsSendAsSmimeInfo.php 0000644 00000012572 15253110636 0014604 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\ListSmimeInfoResponse; use WPMailSMTP\Vendor\Google\Service\Gmail\SmimeInfo; /** * The "smimeInfo" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $smimeInfo = $gmailService->users_settings_sendAs_smimeInfo; * </code> */ class UsersSettingsSendAsSmimeInfo extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Deletes the specified S/MIME config for the specified send-as alias. * (smimeInfo.delete) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $sendAsEmail The email address that appears in the "From:" * header for mail sent using this alias. * @param string $id The immutable ID for the SmimeInfo. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function delete($userId, $sendAsEmail, $id, $optParams = []) { $params = ['userId' => $userId, 'sendAsEmail' => $sendAsEmail, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('delete', [$params]); } /** * Gets the specified S/MIME config for the specified send-as alias. * (smimeInfo.get) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $sendAsEmail The email address that appears in the "From:" * header for mail sent using this alias. * @param string $id The immutable ID for the SmimeInfo. * @param array $optParams Optional parameters. * @return SmimeInfo * @throws \Google\Service\Exception */ public function get($userId, $sendAsEmail, $id, $optParams = []) { $params = ['userId' => $userId, 'sendAsEmail' => $sendAsEmail, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('get', [$params], SmimeInfo::class); } /** * Insert (upload) the given S/MIME config for the specified send-as alias. Note * that pkcs12 format is required for the key. (smimeInfo.insert) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $sendAsEmail The email address that appears in the "From:" * header for mail sent using this alias. * @param SmimeInfo $postBody * @param array $optParams Optional parameters. * @return SmimeInfo * @throws \Google\Service\Exception */ public function insert($userId, $sendAsEmail, SmimeInfo $postBody, $optParams = []) { $params = ['userId' => $userId, 'sendAsEmail' => $sendAsEmail, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('insert', [$params], SmimeInfo::class); } /** * Lists S/MIME configs for the specified send-as alias. * (smimeInfo.listUsersSettingsSendAsSmimeInfo) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $sendAsEmail The email address that appears in the "From:" * header for mail sent using this alias. * @param array $optParams Optional parameters. * @return ListSmimeInfoResponse * @throws \Google\Service\Exception */ public function listUsersSettingsSendAsSmimeInfo($userId, $sendAsEmail, $optParams = []) { $params = ['userId' => $userId, 'sendAsEmail' => $sendAsEmail]; $params = \array_merge($params, $optParams); return $this->call('list', [$params], ListSmimeInfoResponse::class); } /** * Sets the default S/MIME config for the specified send-as alias. * (smimeInfo.setDefault) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $sendAsEmail The email address that appears in the "From:" * header for mail sent using this alias. * @param string $id The immutable ID for the SmimeInfo. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function setDefault($userId, $sendAsEmail, $id, $optParams = []) { $params = ['userId' => $userId, 'sendAsEmail' => $sendAsEmail, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('setDefault', [$params]); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersSettingsSendAsSmimeInfo::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersSettingsSendAsSmimeInfo'); Resource/UsersMessages.php 0000644 00000026656 15253110636 0011656 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\BatchDeleteMessagesRequest; use WPMailSMTP\Vendor\Google\Service\Gmail\BatchModifyMessagesRequest; use WPMailSMTP\Vendor\Google\Service\Gmail\ListMessagesResponse; use WPMailSMTP\Vendor\Google\Service\Gmail\Message; use WPMailSMTP\Vendor\Google\Service\Gmail\ModifyMessageRequest; /** * The "messages" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $messages = $gmailService->users_messages; * </code> */ class UsersMessages extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Deletes many messages by message ID. Provides no guarantees that messages * were not already deleted or even existed at all. (messages.batchDelete) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param BatchDeleteMessagesRequest $postBody * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function batchDelete($userId, BatchDeleteMessagesRequest $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('batchDelete', [$params]); } /** * Modifies the labels on the specified messages. (messages.batchModify) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param BatchModifyMessagesRequest $postBody * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function batchModify($userId, BatchModifyMessagesRequest $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('batchModify', [$params]); } /** * Immediately and permanently deletes the specified message. This operation * cannot be undone. Prefer `messages.trash` instead. (messages.delete) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the message to delete. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function delete($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('delete', [$params]); } /** * Gets the specified message. (messages.get) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the message to retrieve. This ID is usually * retrieved using `messages.list`. The ID is also contained in the result when * a message is inserted (`messages.insert`) or imported (`messages.import`). * @param array $optParams Optional parameters. * * @opt_param string format The format to return the message in. * @opt_param string metadataHeaders When given and format is `METADATA`, only * include headers specified. * @opt_param bool temporaryEeccBypass * @return Message * @throws \Google\Service\Exception */ public function get($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('get', [$params], Message::class); } /** * Imports a message into only this user's mailbox, with standard email delivery * scanning and classification similar to receiving via SMTP. This method * doesn't perform SPF checks, so it might not work for some spam messages, such * as those attempting to perform domain spoofing. This method does not send a * message. (messages.import) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param Message $postBody * @param array $optParams Optional parameters. * * @opt_param bool deleted Mark the email as permanently deleted (not TRASH) and * only visible in Google Vault to a Vault administrator. Only used for Google * Workspace accounts. * @opt_param string internalDateSource Source for Gmail's internal date of the * message. * @opt_param bool neverMarkSpam Ignore the Gmail spam classifier decision and * never mark this email as SPAM in the mailbox. * @opt_param bool processForCalendar Process calendar invites in the email and * add any extracted meetings to the Google Calendar for this user. * @return Message * @throws \Google\Service\Exception */ public function import($userId, Message $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('import', [$params], Message::class); } /** * Directly inserts a message into only this user's mailbox similar to `IMAP * APPEND`, bypassing most scanning and classification. Does not send a message. * (messages.insert) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param Message $postBody * @param array $optParams Optional parameters. * * @opt_param bool deleted Mark the email as permanently deleted (not TRASH) and * only visible in Google Vault to a Vault administrator. Only used for Google * Workspace accounts. * @opt_param string internalDateSource Source for Gmail's internal date of the * message. * @return Message * @throws \Google\Service\Exception */ public function insert($userId, Message $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('insert', [$params], Message::class); } /** * Lists the messages in the user's mailbox. (messages.listUsersMessages) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * * @opt_param bool includeSpamTrash Include messages from `SPAM` and `TRASH` in * the results. * @opt_param string labelIds Only return messages with labels that match all of * the specified label IDs. Messages in a thread might have labels that other * messages in the same thread don't have. To learn more, see [Manage labels on * messages and threads](https://developers.google.com/gmail/api/guides/labels#m * anage_labels_on_messages_threads). * @opt_param string maxResults Maximum number of messages to return. This field * defaults to 100. The maximum allowed value for this field is 500. * @opt_param string pageToken Page token to retrieve a specific page of results * in the list. * @opt_param string q Only return messages matching the specified query. * Supports the same query format as the Gmail search box. For example, * `"from:someuser@example.com rfc822msgid: is:unread"`. Parameter cannot be * used when accessing the api using the gmail.metadata scope. * @opt_param bool temporaryEeccBypass * @return ListMessagesResponse * @throws \Google\Service\Exception */ public function listUsersMessages($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('list', [$params], ListMessagesResponse::class); } /** * Modifies the labels on the specified message. (messages.modify) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the message to modify. * @param ModifyMessageRequest $postBody * @param array $optParams Optional parameters. * @return Message * @throws \Google\Service\Exception */ public function modify($userId, $id, ModifyMessageRequest $postBody, $optParams = []) { $params = ['userId' => $userId, 'id' => $id, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('modify', [$params], Message::class); } /** * Sends the specified message to the recipients in the `To`, `Cc`, and `Bcc` * headers. For example usage, see [Sending * email](https://developers.google.com/gmail/api/guides/sending). * (messages.send) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param Message $postBody * @param array $optParams Optional parameters. * @return Message * @throws \Google\Service\Exception */ public function send($userId, Message $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('send', [$params], Message::class); } /** * Moves the specified message to the trash. (messages.trash) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the message to Trash. * @param array $optParams Optional parameters. * @return Message * @throws \Google\Service\Exception */ public function trash($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('trash', [$params], Message::class); } /** * Removes the specified message from the trash. (messages.untrash) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the message to remove from Trash. * @param array $optParams Optional parameters. * @return Message * @throws \Google\Service\Exception */ public function untrash($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('untrash', [$params], Message::class); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersMessages::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersMessages'); Resource/UsersHistory.php 0000644 00000006154 15253110636 0011537 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\ListHistoryResponse; /** * The "history" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $history = $gmailService->users_history; * </code> */ class UsersHistory extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Lists the history of all changes to the given mailbox. History results are * returned in chronological order (increasing `historyId`). * (history.listUsersHistory) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * * @opt_param string historyTypes History types to be returned by the function * @opt_param string labelId Only return messages with a label matching the ID. * @opt_param string maxResults Maximum number of history records to return. * This field defaults to 100. The maximum allowed value for this field is 500. * @opt_param string pageToken Page token to retrieve a specific page of results * in the list. * @opt_param string startHistoryId Required. Returns history records after the * specified `startHistoryId`. The supplied `startHistoryId` should be obtained * from the `historyId` of a message, thread, or previous `list` response. * History IDs increase chronologically but are not contiguous with random gaps * in between valid IDs. Supplying an invalid or out of date `startHistoryId` * typically returns an `HTTP 404` error code. A `historyId` is typically valid * for at least a week, but in some rare circumstances may be valid for only a * few hours. If you receive an `HTTP 404` error response, your application * should perform a full sync. If you receive no `nextPageToken` in the * response, there are no updates to retrieve and you can store the returned * `historyId` for a future request. * @return ListHistoryResponse * @throws \Google\Service\Exception */ public function listUsersHistory($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('list', [$params], ListHistoryResponse::class); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersHistory::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersHistory'); Resource/UsersThreads.php 0000644 00000014610 15253110636 0011464 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\ListThreadsResponse; use WPMailSMTP\Vendor\Google\Service\Gmail\ModifyThreadRequest; use WPMailSMTP\Vendor\Google\Service\Gmail\Thread; /** * The "threads" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $threads = $gmailService->users_threads; * </code> */ class UsersThreads extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Immediately and permanently deletes the specified thread. Any messages that * belong to the thread are also deleted. This operation cannot be undone. * Prefer `threads.trash` instead. (threads.delete) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id ID of the Thread to delete. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function delete($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('delete', [$params]); } /** * Gets the specified thread. (threads.get) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the thread to retrieve. * @param array $optParams Optional parameters. * * @opt_param string format The format to return the messages in. * @opt_param string metadataHeaders When given and format is METADATA, only * include headers specified. * @opt_param bool temporaryEeccBypass * @return Thread * @throws \Google\Service\Exception */ public function get($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('get', [$params], Thread::class); } /** * Lists the threads in the user's mailbox. (threads.listUsersThreads) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * * @opt_param bool includeSpamTrash Include threads from `SPAM` and `TRASH` in * the results. * @opt_param string labelIds Only return threads with labels that match all of * the specified label IDs. * @opt_param string maxResults Maximum number of threads to return. This field * defaults to 100. The maximum allowed value for this field is 500. * @opt_param string pageToken Page token to retrieve a specific page of results * in the list. * @opt_param string q Only return threads matching the specified query. * Supports the same query format as the Gmail search box. For example, * `"from:someuser@example.com rfc822msgid: is:unread"`. Parameter cannot be * used when accessing the api using the gmail.metadata scope. * @opt_param bool temporaryEeccBypass * @return ListThreadsResponse * @throws \Google\Service\Exception */ public function listUsersThreads($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('list', [$params], ListThreadsResponse::class); } /** * Modifies the labels applied to the thread. This applies to all messages in * the thread. (threads.modify) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the thread to modify. * @param ModifyThreadRequest $postBody * @param array $optParams Optional parameters. * @return Thread * @throws \Google\Service\Exception */ public function modify($userId, $id, ModifyThreadRequest $postBody, $optParams = []) { $params = ['userId' => $userId, 'id' => $id, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('modify', [$params], Thread::class); } /** * Moves the specified thread to the trash. Any messages that belong to the * thread are also moved to the trash. (threads.trash) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the thread to Trash. * @param array $optParams Optional parameters. * @return Thread * @throws \Google\Service\Exception */ public function trash($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('trash', [$params], Thread::class); } /** * Removes the specified thread from the trash. Any messages that belong to the * thread are also removed from the trash. (threads.untrash) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $id The ID of the thread to remove from Trash. * @param array $optParams Optional parameters. * @return Thread * @throws \Google\Service\Exception */ public function untrash($userId, $id, $optParams = []) { $params = ['userId' => $userId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('untrash', [$params], Thread::class); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersThreads::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersThreads'); Resource/UsersSettingsCseKeypairs.php 0000644 00000016053 15253110636 0014040 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\CseKeyPair; use WPMailSMTP\Vendor\Google\Service\Gmail\DisableCseKeyPairRequest; use WPMailSMTP\Vendor\Google\Service\Gmail\EnableCseKeyPairRequest; use WPMailSMTP\Vendor\Google\Service\Gmail\ListCseKeyPairsResponse; use WPMailSMTP\Vendor\Google\Service\Gmail\ObliterateCseKeyPairRequest; /** * The "keypairs" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $keypairs = $gmailService->users_settings_cse_keypairs; * </code> */ class UsersSettingsCseKeypairs extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Creates and uploads a client-side encryption S/MIME public key certificate * chain and private key metadata for the authenticated user. (keypairs.create) * * @param string $userId The requester's primary email address. To indicate the * authenticated user, you can use the special value `me`. * @param CseKeyPair $postBody * @param array $optParams Optional parameters. * @return CseKeyPair * @throws \Google\Service\Exception */ public function create($userId, CseKeyPair $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('create', [$params], CseKeyPair::class); } /** * Turns off a client-side encryption key pair. The authenticated user can no * longer use the key pair to decrypt incoming CSE message texts or sign * outgoing CSE mail. To regain access, use the EnableCseKeyPair to turn on the * key pair. After 30 days, you can permanently delete the key pair by using the * ObliterateCseKeyPair method. (keypairs.disable) * * @param string $userId The requester's primary email address. To indicate the * authenticated user, you can use the special value `me`. * @param string $keyPairId The identifier of the key pair to turn off. * @param DisableCseKeyPairRequest $postBody * @param array $optParams Optional parameters. * @return CseKeyPair * @throws \Google\Service\Exception */ public function disable($userId, $keyPairId, DisableCseKeyPairRequest $postBody, $optParams = []) { $params = ['userId' => $userId, 'keyPairId' => $keyPairId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('disable', [$params], CseKeyPair::class); } /** * Turns on a client-side encryption key pair that was turned off. The key pair * becomes active again for any associated client-side encryption identities. * (keypairs.enable) * * @param string $userId The requester's primary email address. To indicate the * authenticated user, you can use the special value `me`. * @param string $keyPairId The identifier of the key pair to turn on. * @param EnableCseKeyPairRequest $postBody * @param array $optParams Optional parameters. * @return CseKeyPair * @throws \Google\Service\Exception */ public function enable($userId, $keyPairId, EnableCseKeyPairRequest $postBody, $optParams = []) { $params = ['userId' => $userId, 'keyPairId' => $keyPairId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('enable', [$params], CseKeyPair::class); } /** * Retrieves an existing client-side encryption key pair. (keypairs.get) * * @param string $userId The requester's primary email address. To indicate the * authenticated user, you can use the special value `me`. * @param string $keyPairId The identifier of the key pair to retrieve. * @param array $optParams Optional parameters. * @return CseKeyPair * @throws \Google\Service\Exception */ public function get($userId, $keyPairId, $optParams = []) { $params = ['userId' => $userId, 'keyPairId' => $keyPairId]; $params = \array_merge($params, $optParams); return $this->call('get', [$params], CseKeyPair::class); } /** * Lists client-side encryption key pairs for an authenticated user. * (keypairs.listUsersSettingsCseKeypairs) * * @param string $userId The requester's primary email address. To indicate the * authenticated user, you can use the special value `me`. * @param array $optParams Optional parameters. * * @opt_param int pageSize The number of key pairs to return. If not provided, * the page size will default to 20 entries. * @opt_param string pageToken Pagination token indicating which page of key * pairs to return. If the token is not supplied, then the API will return the * first page of results. * @return ListCseKeyPairsResponse * @throws \Google\Service\Exception */ public function listUsersSettingsCseKeypairs($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('list', [$params], ListCseKeyPairsResponse::class); } /** * Deletes a client-side encryption key pair permanently and immediately. You * can only permanently delete key pairs that have been turned off for more than * 30 days. To turn off a key pair, use the DisableCseKeyPair method. Gmail * can't restore or decrypt any messages that were encrypted by an obliterated * key. Authenticated users and Google Workspace administrators lose access to * reading the encrypted messages. (keypairs.obliterate) * * @param string $userId The requester's primary email address. To indicate the * authenticated user, you can use the special value `me`. * @param string $keyPairId The identifier of the key pair to obliterate. * @param ObliterateCseKeyPairRequest $postBody * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function obliterate($userId, $keyPairId, ObliterateCseKeyPairRequest $postBody, $optParams = []) { $params = ['userId' => $userId, 'keyPairId' => $keyPairId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('obliterate', [$params]); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersSettingsCseKeypairs::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersSettingsCseKeypairs'); Resource/UsersSettingsCseIdentities.php 0000644 00000013705 15253110636 0014353 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\CseIdentity; use WPMailSMTP\Vendor\Google\Service\Gmail\ListCseIdentitiesResponse; /** * The "identities" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $identities = $gmailService->users_settings_cse_identities; * </code> */ class UsersSettingsCseIdentities extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Creates and configures a client-side encryption identity that's authorized to * send mail from the user account. Google publishes the S/MIME certificate to a * shared domain-wide directory so that people within a Google Workspace * organization can encrypt and send mail to the identity. (identities.create) * * @param string $userId The requester's primary email address. To indicate the * authenticated user, you can use the special value `me`. * @param CseIdentity $postBody * @param array $optParams Optional parameters. * @return CseIdentity * @throws \Google\Service\Exception */ public function create($userId, CseIdentity $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('create', [$params], CseIdentity::class); } /** * Deletes a client-side encryption identity. The authenticated user can no * longer use the identity to send encrypted messages. You cannot restore the * identity after you delete it. Instead, use the CreateCseIdentity method to * create another identity with the same configuration. (identities.delete) * * @param string $userId The requester's primary email address. To indicate the * authenticated user, you can use the special value `me`. * @param string $cseEmailAddress The primary email address associated with the * client-side encryption identity configuration that's removed. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function delete($userId, $cseEmailAddress, $optParams = []) { $params = ['userId' => $userId, 'cseEmailAddress' => $cseEmailAddress]; $params = \array_merge($params, $optParams); return $this->call('delete', [$params]); } /** * Retrieves a client-side encryption identity configuration. (identities.get) * * @param string $userId The requester's primary email address. To indicate the * authenticated user, you can use the special value `me`. * @param string $cseEmailAddress The primary email address associated with the * client-side encryption identity configuration that's retrieved. * @param array $optParams Optional parameters. * @return CseIdentity * @throws \Google\Service\Exception */ public function get($userId, $cseEmailAddress, $optParams = []) { $params = ['userId' => $userId, 'cseEmailAddress' => $cseEmailAddress]; $params = \array_merge($params, $optParams); return $this->call('get', [$params], CseIdentity::class); } /** * Lists the client-side encrypted identities for an authenticated user. * (identities.listUsersSettingsCseIdentities) * * @param string $userId The requester's primary email address. To indicate the * authenticated user, you can use the special value `me`. * @param array $optParams Optional parameters. * * @opt_param int pageSize The number of identities to return. If not provided, * the page size will default to 20 entries. * @opt_param string pageToken Pagination token indicating which page of * identities to return. If the token is not supplied, then the API will return * the first page of results. * @return ListCseIdentitiesResponse * @throws \Google\Service\Exception */ public function listUsersSettingsCseIdentities($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('list', [$params], ListCseIdentitiesResponse::class); } /** * Associates a different key pair with an existing client-side encryption * identity. The updated key pair must validate against Google's [S/MIME * certificate profiles](https://support.google.com/a/answer/7300887). * (identities.patch) * * @param string $userId The requester's primary email address. To indicate the * authenticated user, you can use the special value `me`. * @param string $emailAddress The email address of the client-side encryption * identity to update. * @param CseIdentity $postBody * @param array $optParams Optional parameters. * @return CseIdentity * @throws \Google\Service\Exception */ public function patch($userId, $emailAddress, CseIdentity $postBody, $optParams = []) { $params = ['userId' => $userId, 'emailAddress' => $emailAddress, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('patch', [$params], CseIdentity::class); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersSettingsCseIdentities::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersSettingsCseIdentities'); Resource/UsersSettingsDelegates.php 0000644 00000012471 15253110636 0013513 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\Delegate; use WPMailSMTP\Vendor\Google\Service\Gmail\ListDelegatesResponse; /** * The "delegates" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $delegates = $gmailService->users_settings_delegates; * </code> */ class UsersSettingsDelegates extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Adds a delegate with its verification status set directly to `accepted`, * without sending any verification email. The delegate user must be a member of * the same Google Workspace organization as the delegator user. Gmail imposes * limitations on the number of delegates and delegators each user in a Google * Workspace organization can have. These limits depend on your organization, * but in general each user can have up to 25 delegates and up to 10 delegators. * Note that a delegate user must be referred to by their primary email address, * and not an email alias. Also note that when a new delegate is created, there * may be up to a one minute delay before the new delegate is available for use. * This method is only available to service account clients that have been * delegated domain-wide authority. (delegates.create) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param Delegate $postBody * @param array $optParams Optional parameters. * @return Delegate * @throws \Google\Service\Exception */ public function create($userId, Delegate $postBody, $optParams = []) { $params = ['userId' => $userId, 'postBody' => $postBody]; $params = \array_merge($params, $optParams); return $this->call('create', [$params], Delegate::class); } /** * Removes the specified delegate (which can be of any verification status), and * revokes any verification that may have been required for using it. Note that * a delegate user must be referred to by their primary email address, and not * an email alias. This method is only available to service account clients that * have been delegated domain-wide authority. (delegates.delete) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param string $delegateEmail The email address of the user to be removed as a * delegate. * @param array $optParams Optional parameters. * @throws \Google\Service\Exception */ public function delete($userId, $delegateEmail, $optParams = []) { $params = ['userId' => $userId, 'delegateEmail' => $delegateEmail]; $params = \array_merge($params, $optParams); return $this->call('delete', [$params]); } /** * Gets the specified delegate. Note that a delegate user must be referred to by * their primary email address, and not an email alias. This method is only * available to service account clients that have been delegated domain-wide * authority. (delegates.get) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param string $delegateEmail The email address of the user whose delegate * relationship is to be retrieved. * @param array $optParams Optional parameters. * @return Delegate * @throws \Google\Service\Exception */ public function get($userId, $delegateEmail, $optParams = []) { $params = ['userId' => $userId, 'delegateEmail' => $delegateEmail]; $params = \array_merge($params, $optParams); return $this->call('get', [$params], Delegate::class); } /** * Lists the delegates for the specified account. This method is only available * to service account clients that have been delegated domain-wide authority. * (delegates.listUsersSettingsDelegates) * * @param string $userId User's email address. The special value "me" can be * used to indicate the authenticated user. * @param array $optParams Optional parameters. * @return ListDelegatesResponse * @throws \Google\Service\Exception */ public function listUsersSettingsDelegates($userId, $optParams = []) { $params = ['userId' => $userId]; $params = \array_merge($params, $optParams); return $this->call('list', [$params], ListDelegatesResponse::class); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersSettingsDelegates::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersSettingsDelegates'); Resource/UsersMessagesAttachments.php 0000644 00000003757 15253110636 0014047 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail\Resource; use WPMailSMTP\Vendor\Google\Service\Gmail\MessagePartBody; /** * The "attachments" collection of methods. * Typical usage is: * <code> * $gmailService = new Google\Service\Gmail(...); * $attachments = $gmailService->users_messages_attachments; * </code> */ class UsersMessagesAttachments extends \WPMailSMTP\Vendor\Google\Service\Resource { /** * Gets the specified message attachment. (attachments.get) * * @param string $userId The user's email address. The special value `me` can be * used to indicate the authenticated user. * @param string $messageId The ID of the message containing the attachment. * @param string $id The ID of the attachment. * @param array $optParams Optional parameters. * * @opt_param bool temporaryEeccBypass * @return MessagePartBody * @throws \Google\Service\Exception */ public function get($userId, $messageId, $id, $optParams = []) { $params = ['userId' => $userId, 'messageId' => $messageId, 'id' => $id]; $params = \array_merge($params, $optParams); return $this->call('get', [$params], MessagePartBody::class); } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(UsersMessagesAttachments::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Resource_UsersMessagesAttachments'); Delegate.php 0000644 00000003057 15253110636 0006776 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class Delegate extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $delegateEmail; /** * @var string */ public $verificationStatus; /** * @param string */ public function setDelegateEmail($delegateEmail) { $this->delegateEmail = $delegateEmail; } /** * @return string */ public function getDelegateEmail() { return $this->delegateEmail; } /** * @param string */ public function setVerificationStatus($verificationStatus) { $this->verificationStatus = $verificationStatus; } /** * @return string */ public function getVerificationStatus() { return $this->verificationStatus; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(Delegate::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Delegate'); VacationSettings.php 0000644 00000007123 15253110636 0010547 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class VacationSettings extends \WPMailSMTP\Vendor\Google\Model { /** * @var bool */ public $enableAutoReply; /** * @var string */ public $endTime; /** * @var string */ public $responseBodyHtml; /** * @var string */ public $responseBodyPlainText; /** * @var string */ public $responseSubject; /** * @var bool */ public $restrictToContacts; /** * @var bool */ public $restrictToDomain; /** * @var string */ public $startTime; /** * @param bool */ public function setEnableAutoReply($enableAutoReply) { $this->enableAutoReply = $enableAutoReply; } /** * @return bool */ public function getEnableAutoReply() { return $this->enableAutoReply; } /** * @param string */ public function setEndTime($endTime) { $this->endTime = $endTime; } /** * @return string */ public function getEndTime() { return $this->endTime; } /** * @param string */ public function setResponseBodyHtml($responseBodyHtml) { $this->responseBodyHtml = $responseBodyHtml; } /** * @return string */ public function getResponseBodyHtml() { return $this->responseBodyHtml; } /** * @param string */ public function setResponseBodyPlainText($responseBodyPlainText) { $this->responseBodyPlainText = $responseBodyPlainText; } /** * @return string */ public function getResponseBodyPlainText() { return $this->responseBodyPlainText; } /** * @param string */ public function setResponseSubject($responseSubject) { $this->responseSubject = $responseSubject; } /** * @return string */ public function getResponseSubject() { return $this->responseSubject; } /** * @param bool */ public function setRestrictToContacts($restrictToContacts) { $this->restrictToContacts = $restrictToContacts; } /** * @return bool */ public function getRestrictToContacts() { return $this->restrictToContacts; } /** * @param bool */ public function setRestrictToDomain($restrictToDomain) { $this->restrictToDomain = $restrictToDomain; } /** * @return bool */ public function getRestrictToDomain() { return $this->restrictToDomain; } /** * @param string */ public function setStartTime($startTime) { $this->startTime = $startTime; } /** * @return string */ public function getStartTime() { return $this->startTime; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(VacationSettings::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_VacationSettings'); ObliterateCseKeyPairRequest.php 0000644 00000001643 15253110636 0012646 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ObliterateCseKeyPairRequest extends \WPMailSMTP\Vendor\Google\Model { } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ObliterateCseKeyPairRequest::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ObliterateCseKeyPairRequest'); CsePrivateKeyMetadata.php 0000644 00000004245 15253110636 0011443 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class CsePrivateKeyMetadata extends \WPMailSMTP\Vendor\Google\Model { protected $hardwareKeyMetadataType = HardwareKeyMetadata::class; protected $hardwareKeyMetadataDataType = ''; protected $kaclsKeyMetadataType = KaclsKeyMetadata::class; protected $kaclsKeyMetadataDataType = ''; /** * @var string */ public $privateKeyMetadataId; /** * @param HardwareKeyMetadata */ public function setHardwareKeyMetadata(HardwareKeyMetadata $hardwareKeyMetadata) { $this->hardwareKeyMetadata = $hardwareKeyMetadata; } /** * @return HardwareKeyMetadata */ public function getHardwareKeyMetadata() { return $this->hardwareKeyMetadata; } /** * @param KaclsKeyMetadata */ public function setKaclsKeyMetadata(KaclsKeyMetadata $kaclsKeyMetadata) { $this->kaclsKeyMetadata = $kaclsKeyMetadata; } /** * @return KaclsKeyMetadata */ public function getKaclsKeyMetadata() { return $this->kaclsKeyMetadata; } /** * @param string */ public function setPrivateKeyMetadataId($privateKeyMetadataId) { $this->privateKeyMetadataId = $privateKeyMetadataId; } /** * @return string */ public function getPrivateKeyMetadataId() { return $this->privateKeyMetadataId; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(CsePrivateKeyMetadata::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_CsePrivateKeyMetadata'); ListSmimeInfoResponse.php 0000644 00000002445 15253110636 0011525 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ListSmimeInfoResponse extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'smimeInfo'; protected $smimeInfoType = SmimeInfo::class; protected $smimeInfoDataType = 'array'; /** * @param SmimeInfo[] */ public function setSmimeInfo($smimeInfo) { $this->smimeInfo = $smimeInfo; } /** * @return SmimeInfo[] */ public function getSmimeInfo() { return $this->smimeInfo; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ListSmimeInfoResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ListSmimeInfoResponse'); ListForwardingAddressesResponse.php 0000644 00000002665 15253110636 0013603 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ListForwardingAddressesResponse extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'forwardingAddresses'; protected $forwardingAddressesType = ForwardingAddress::class; protected $forwardingAddressesDataType = 'array'; /** * @param ForwardingAddress[] */ public function setForwardingAddresses($forwardingAddresses) { $this->forwardingAddresses = $forwardingAddresses; } /** * @return ForwardingAddress[] */ public function getForwardingAddresses() { return $this->forwardingAddresses; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ListForwardingAddressesResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ListForwardingAddressesResponse'); HistoryMessageAdded.php 0000644 00000002326 15253110636 0011152 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class HistoryMessageAdded extends \WPMailSMTP\Vendor\Google\Model { protected $messageType = Message::class; protected $messageDataType = ''; /** * @param Message */ public function setMessage(Message $message) { $this->message = $message; } /** * @return Message */ public function getMessage() { return $this->message; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(HistoryMessageAdded::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_HistoryMessageAdded'); SendAs.php 0000644 00000007330 15253110636 0006437 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class SendAs extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $displayName; /** * @var bool */ public $isDefault; /** * @var bool */ public $isPrimary; /** * @var string */ public $replyToAddress; /** * @var string */ public $sendAsEmail; /** * @var string */ public $signature; protected $smtpMsaType = SmtpMsa::class; protected $smtpMsaDataType = ''; /** * @var bool */ public $treatAsAlias; /** * @var string */ public $verificationStatus; /** * @param string */ public function setDisplayName($displayName) { $this->displayName = $displayName; } /** * @return string */ public function getDisplayName() { return $this->displayName; } /** * @param bool */ public function setIsDefault($isDefault) { $this->isDefault = $isDefault; } /** * @return bool */ public function getIsDefault() { return $this->isDefault; } /** * @param bool */ public function setIsPrimary($isPrimary) { $this->isPrimary = $isPrimary; } /** * @return bool */ public function getIsPrimary() { return $this->isPrimary; } /** * @param string */ public function setReplyToAddress($replyToAddress) { $this->replyToAddress = $replyToAddress; } /** * @return string */ public function getReplyToAddress() { return $this->replyToAddress; } /** * @param string */ public function setSendAsEmail($sendAsEmail) { $this->sendAsEmail = $sendAsEmail; } /** * @return string */ public function getSendAsEmail() { return $this->sendAsEmail; } /** * @param string */ public function setSignature($signature) { $this->signature = $signature; } /** * @return string */ public function getSignature() { return $this->signature; } /** * @param SmtpMsa */ public function setSmtpMsa(SmtpMsa $smtpMsa) { $this->smtpMsa = $smtpMsa; } /** * @return SmtpMsa */ public function getSmtpMsa() { return $this->smtpMsa; } /** * @param bool */ public function setTreatAsAlias($treatAsAlias) { $this->treatAsAlias = $treatAsAlias; } /** * @return bool */ public function getTreatAsAlias() { return $this->treatAsAlias; } /** * @param string */ public function setVerificationStatus($verificationStatus) { $this->verificationStatus = $verificationStatus; } /** * @return string */ public function getVerificationStatus() { return $this->verificationStatus; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(SendAs::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_SendAs'); MessagePart.php 0000644 00000005442 15253110636 0007477 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class MessagePart extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'parts'; protected $bodyType = MessagePartBody::class; protected $bodyDataType = ''; /** * @var string */ public $filename; protected $headersType = MessagePartHeader::class; protected $headersDataType = 'array'; /** * @var string */ public $mimeType; /** * @var string */ public $partId; protected $partsType = MessagePart::class; protected $partsDataType = 'array'; /** * @param MessagePartBody */ public function setBody(MessagePartBody $body) { $this->body = $body; } /** * @return MessagePartBody */ public function getBody() { return $this->body; } /** * @param string */ public function setFilename($filename) { $this->filename = $filename; } /** * @return string */ public function getFilename() { return $this->filename; } /** * @param MessagePartHeader[] */ public function setHeaders($headers) { $this->headers = $headers; } /** * @return MessagePartHeader[] */ public function getHeaders() { return $this->headers; } /** * @param string */ public function setMimeType($mimeType) { $this->mimeType = $mimeType; } /** * @return string */ public function getMimeType() { return $this->mimeType; } /** * @param string */ public function setPartId($partId) { $this->partId = $partId; } /** * @return string */ public function getPartId() { return $this->partId; } /** * @param MessagePart[] */ public function setParts($parts) { $this->parts = $parts; } /** * @return MessagePart[] */ public function getParts() { return $this->parts; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(MessagePart::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_MessagePart'); Thread.php 0000644 00000004111 15253110636 0006463 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class Thread extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'messages'; /** * @var string */ public $historyId; /** * @var string */ public $id; protected $messagesType = Message::class; protected $messagesDataType = 'array'; /** * @var string */ public $snippet; /** * @param string */ public function setHistoryId($historyId) { $this->historyId = $historyId; } /** * @return string */ public function getHistoryId() { return $this->historyId; } /** * @param string */ public function setId($id) { $this->id = $id; } /** * @return string */ public function getId() { return $this->id; } /** * @param Message[] */ public function setMessages($messages) { $this->messages = $messages; } /** * @return Message[] */ public function getMessages() { return $this->messages; } /** * @param string */ public function setSnippet($snippet) { $this->snippet = $snippet; } /** * @return string */ public function getSnippet() { return $this->snippet; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(Thread::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Thread'); BatchModifyMessagesRequest.php 0000644 00000003617 15253110636 0012520 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class BatchModifyMessagesRequest extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'removeLabelIds'; /** * @var string[] */ public $addLabelIds; /** * @var string[] */ public $ids; /** * @var string[] */ public $removeLabelIds; /** * @param string[] */ public function setAddLabelIds($addLabelIds) { $this->addLabelIds = $addLabelIds; } /** * @return string[] */ public function getAddLabelIds() { return $this->addLabelIds; } /** * @param string[] */ public function setIds($ids) { $this->ids = $ids; } /** * @return string[] */ public function getIds() { return $this->ids; } /** * @param string[] */ public function setRemoveLabelIds($removeLabelIds) { $this->removeLabelIds = $removeLabelIds; } /** * @return string[] */ public function getRemoveLabelIds() { return $this->removeLabelIds; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(BatchModifyMessagesRequest::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_BatchModifyMessagesRequest'); Label.php 0000644 00000007764 15253110636 0006314 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class Label extends \WPMailSMTP\Vendor\Google\Model { protected $colorType = LabelColor::class; protected $colorDataType = ''; /** * @var string */ public $id; /** * @var string */ public $labelListVisibility; /** * @var string */ public $messageListVisibility; /** * @var int */ public $messagesTotal; /** * @var int */ public $messagesUnread; /** * @var string */ public $name; /** * @var int */ public $threadsTotal; /** * @var int */ public $threadsUnread; /** * @var string */ public $type; /** * @param LabelColor */ public function setColor(LabelColor $color) { $this->color = $color; } /** * @return LabelColor */ public function getColor() { return $this->color; } /** * @param string */ public function setId($id) { $this->id = $id; } /** * @return string */ public function getId() { return $this->id; } /** * @param string */ public function setLabelListVisibility($labelListVisibility) { $this->labelListVisibility = $labelListVisibility; } /** * @return string */ public function getLabelListVisibility() { return $this->labelListVisibility; } /** * @param string */ public function setMessageListVisibility($messageListVisibility) { $this->messageListVisibility = $messageListVisibility; } /** * @return string */ public function getMessageListVisibility() { return $this->messageListVisibility; } /** * @param int */ public function setMessagesTotal($messagesTotal) { $this->messagesTotal = $messagesTotal; } /** * @return int */ public function getMessagesTotal() { return $this->messagesTotal; } /** * @param int */ public function setMessagesUnread($messagesUnread) { $this->messagesUnread = $messagesUnread; } /** * @return int */ public function getMessagesUnread() { return $this->messagesUnread; } /** * @param string */ public function setName($name) { $this->name = $name; } /** * @return string */ public function getName() { return $this->name; } /** * @param int */ public function setThreadsTotal($threadsTotal) { $this->threadsTotal = $threadsTotal; } /** * @return int */ public function getThreadsTotal() { return $this->threadsTotal; } /** * @param int */ public function setThreadsUnread($threadsUnread) { $this->threadsUnread = $threadsUnread; } /** * @return int */ public function getThreadsUnread() { return $this->threadsUnread; } /** * @param string */ public function setType($type) { $this->type = $type; } /** * @return string */ public function getType() { return $this->type; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(Label::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Label'); WatchResponse.php 0000644 00000002752 15253110636 0010052 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class WatchResponse extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $expiration; /** * @var string */ public $historyId; /** * @param string */ public function setExpiration($expiration) { $this->expiration = $expiration; } /** * @return string */ public function getExpiration() { return $this->expiration; } /** * @param string */ public function setHistoryId($historyId) { $this->historyId = $historyId; } /** * @return string */ public function getHistoryId() { return $this->historyId; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(WatchResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_WatchResponse'); BatchDeleteMessagesRequest.php 0000644 00000002335 15253110636 0012467 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class BatchDeleteMessagesRequest extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'ids'; /** * @var string[] */ public $ids; /** * @param string[] */ public function setIds($ids) { $this->ids = $ids; } /** * @return string[] */ public function getIds() { return $this->ids; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(BatchDeleteMessagesRequest::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_BatchDeleteMessagesRequest'); Draft.php 0000644 00000002660 15253110636 0006323 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class Draft extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $id; protected $messageType = Message::class; protected $messageDataType = ''; /** * @param string */ public function setId($id) { $this->id = $id; } /** * @return string */ public function getId() { return $this->id; } /** * @param Message */ public function setMessage(Message $message) { $this->message = $message; } /** * @return Message */ public function getMessage() { return $this->message; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(Draft::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Draft'); CseKeyPair.php 0000644 00000006406 15253110636 0007264 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class CseKeyPair extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'subjectEmailAddresses'; /** * @var string */ public $disableTime; /** * @var string */ public $enablementState; /** * @var string */ public $keyPairId; /** * @var string */ public $pem; /** * @var string */ public $pkcs7; protected $privateKeyMetadataType = CsePrivateKeyMetadata::class; protected $privateKeyMetadataDataType = 'array'; /** * @var string[] */ public $subjectEmailAddresses; /** * @param string */ public function setDisableTime($disableTime) { $this->disableTime = $disableTime; } /** * @return string */ public function getDisableTime() { return $this->disableTime; } /** * @param string */ public function setEnablementState($enablementState) { $this->enablementState = $enablementState; } /** * @return string */ public function getEnablementState() { return $this->enablementState; } /** * @param string */ public function setKeyPairId($keyPairId) { $this->keyPairId = $keyPairId; } /** * @return string */ public function getKeyPairId() { return $this->keyPairId; } /** * @param string */ public function setPem($pem) { $this->pem = $pem; } /** * @return string */ public function getPem() { return $this->pem; } /** * @param string */ public function setPkcs7($pkcs7) { $this->pkcs7 = $pkcs7; } /** * @return string */ public function getPkcs7() { return $this->pkcs7; } /** * @param CsePrivateKeyMetadata[] */ public function setPrivateKeyMetadata($privateKeyMetadata) { $this->privateKeyMetadata = $privateKeyMetadata; } /** * @return CsePrivateKeyMetadata[] */ public function getPrivateKeyMetadata() { return $this->privateKeyMetadata; } /** * @param string[] */ public function setSubjectEmailAddresses($subjectEmailAddresses) { $this->subjectEmailAddresses = $subjectEmailAddresses; } /** * @return string[] */ public function getSubjectEmailAddresses() { return $this->subjectEmailAddresses; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(CseKeyPair::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_CseKeyPair'); LabelColor.php 0000644 00000003004 15253110636 0007272 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class LabelColor extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $backgroundColor; /** * @var string */ public $textColor; /** * @param string */ public function setBackgroundColor($backgroundColor) { $this->backgroundColor = $backgroundColor; } /** * @return string */ public function getBackgroundColor() { return $this->backgroundColor; } /** * @param string */ public function setTextColor($textColor) { $this->textColor = $textColor; } /** * @return string */ public function getTextColor() { return $this->textColor; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(LabelColor::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_LabelColor'); ListCseKeyPairsResponse.php 0000644 00000003221 15253110636 0012012 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ListCseKeyPairsResponse extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'cseKeyPairs'; protected $cseKeyPairsType = CseKeyPair::class; protected $cseKeyPairsDataType = 'array'; /** * @var string */ public $nextPageToken; /** * @param CseKeyPair[] */ public function setCseKeyPairs($cseKeyPairs) { $this->cseKeyPairs = $cseKeyPairs; } /** * @return CseKeyPair[] */ public function getCseKeyPairs() { return $this->cseKeyPairs; } /** * @param string */ public function setNextPageToken($nextPageToken) { $this->nextPageToken = $nextPageToken; } /** * @return string */ public function getNextPageToken() { return $this->nextPageToken; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ListCseKeyPairsResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ListCseKeyPairsResponse'); MessagePartHeader.php 0000644 00000002660 15253110636 0010607 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class MessagePartHeader extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $name; /** * @var string */ public $value; /** * @param string */ public function setName($name) { $this->name = $name; } /** * @return string */ public function getName() { return $this->name; } /** * @param string */ public function setValue($value) { $this->value = $value; } /** * @return string */ public function getValue() { return $this->value; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(MessagePartHeader::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_MessagePartHeader'); ListCseIdentitiesResponse.php 0000644 00000003254 15253110636 0012372 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ListCseIdentitiesResponse extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'cseIdentities'; protected $cseIdentitiesType = CseIdentity::class; protected $cseIdentitiesDataType = 'array'; /** * @var string */ public $nextPageToken; /** * @param CseIdentity[] */ public function setCseIdentities($cseIdentities) { $this->cseIdentities = $cseIdentities; } /** * @return CseIdentity[] */ public function getCseIdentities() { return $this->cseIdentities; } /** * @param string */ public function setNextPageToken($nextPageToken) { $this->nextPageToken = $nextPageToken; } /** * @return string */ public function getNextPageToken() { return $this->nextPageToken; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ListCseIdentitiesResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ListCseIdentitiesResponse'); ForwardingAddress.php 0000644 00000003130 15253110636 0010664 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ForwardingAddress extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $forwardingEmail; /** * @var string */ public $verificationStatus; /** * @param string */ public function setForwardingEmail($forwardingEmail) { $this->forwardingEmail = $forwardingEmail; } /** * @return string */ public function getForwardingEmail() { return $this->forwardingEmail; } /** * @param string */ public function setVerificationStatus($verificationStatus) { $this->verificationStatus = $verificationStatus; } /** * @return string */ public function getVerificationStatus() { return $this->verificationStatus; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ForwardingAddress::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ForwardingAddress'); KaclsKeyMetadata.php 0000644 00000002745 15253110636 0010436 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class KaclsKeyMetadata extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $kaclsData; /** * @var string */ public $kaclsUri; /** * @param string */ public function setKaclsData($kaclsData) { $this->kaclsData = $kaclsData; } /** * @return string */ public function getKaclsData() { return $this->kaclsData; } /** * @param string */ public function setKaclsUri($kaclsUri) { $this->kaclsUri = $kaclsUri; } /** * @return string */ public function getKaclsUri() { return $this->kaclsUri; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(KaclsKeyMetadata::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_KaclsKeyMetadata'); ImapSettings.php 0000644 00000004173 15253110636 0007673 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ImapSettings extends \WPMailSMTP\Vendor\Google\Model { /** * @var bool */ public $autoExpunge; /** * @var bool */ public $enabled; /** * @var string */ public $expungeBehavior; /** * @var int */ public $maxFolderSize; /** * @param bool */ public function setAutoExpunge($autoExpunge) { $this->autoExpunge = $autoExpunge; } /** * @return bool */ public function getAutoExpunge() { return $this->autoExpunge; } /** * @param bool */ public function setEnabled($enabled) { $this->enabled = $enabled; } /** * @return bool */ public function getEnabled() { return $this->enabled; } /** * @param string */ public function setExpungeBehavior($expungeBehavior) { $this->expungeBehavior = $expungeBehavior; } /** * @return string */ public function getExpungeBehavior() { return $this->expungeBehavior; } /** * @param int */ public function setMaxFolderSize($maxFolderSize) { $this->maxFolderSize = $maxFolderSize; } /** * @return int */ public function getMaxFolderSize() { return $this->maxFolderSize; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ImapSettings::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ImapSettings'); HistoryLabelRemoved.php 0000644 00000003073 15253110636 0011205 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class HistoryLabelRemoved extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'labelIds'; /** * @var string[] */ public $labelIds; protected $messageType = Message::class; protected $messageDataType = ''; /** * @param string[] */ public function setLabelIds($labelIds) { $this->labelIds = $labelIds; } /** * @return string[] */ public function getLabelIds() { return $this->labelIds; } /** * @param Message */ public function setMessage(Message $message) { $this->message = $message; } /** * @return Message */ public function getMessage() { return $this->message; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(HistoryLabelRemoved::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_HistoryLabelRemoved'); EnableCseKeyPairRequest.php 0000644 00000001627 15253110636 0011744 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class EnableCseKeyPairRequest extends \WPMailSMTP\Vendor\Google\Model { } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(EnableCseKeyPairRequest::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_EnableCseKeyPairRequest'); SignAndEncryptKeyPairs.php 0000644 00000003165 15253110636 0011624 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class SignAndEncryptKeyPairs extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $encryptionKeyPairId; /** * @var string */ public $signingKeyPairId; /** * @param string */ public function setEncryptionKeyPairId($encryptionKeyPairId) { $this->encryptionKeyPairId = $encryptionKeyPairId; } /** * @return string */ public function getEncryptionKeyPairId() { return $this->encryptionKeyPairId; } /** * @param string */ public function setSigningKeyPairId($signingKeyPairId) { $this->signingKeyPairId = $signingKeyPairId; } /** * @return string */ public function getSigningKeyPairId() { return $this->signingKeyPairId; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(SignAndEncryptKeyPairs::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_SignAndEncryptKeyPairs'); ListDelegatesResponse.php 0000644 00000002442 15253110636 0011531 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ListDelegatesResponse extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'delegates'; protected $delegatesType = Delegate::class; protected $delegatesDataType = 'array'; /** * @param Delegate[] */ public function setDelegates($delegates) { $this->delegates = $delegates; } /** * @return Delegate[] */ public function getDelegates() { return $this->delegates; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ListDelegatesResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ListDelegatesResponse'); ListMessagesResponse.php 0000644 00000003730 15253110636 0011404 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ListMessagesResponse extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'messages'; protected $messagesType = Message::class; protected $messagesDataType = 'array'; /** * @var string */ public $nextPageToken; /** * @var string */ public $resultSizeEstimate; /** * @param Message[] */ public function setMessages($messages) { $this->messages = $messages; } /** * @return Message[] */ public function getMessages() { return $this->messages; } /** * @param string */ public function setNextPageToken($nextPageToken) { $this->nextPageToken = $nextPageToken; } /** * @return string */ public function getNextPageToken() { return $this->nextPageToken; } /** * @param string */ public function setResultSizeEstimate($resultSizeEstimate) { $this->resultSizeEstimate = $resultSizeEstimate; } /** * @return string */ public function getResultSizeEstimate() { return $this->resultSizeEstimate; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ListMessagesResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ListMessagesResponse'); HardwareKeyMetadata.php 0000644 00000002316 15253110636 0011130 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class HardwareKeyMetadata extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $description; /** * @param string */ public function setDescription($description) { $this->description = $description; } /** * @return string */ public function getDescription() { return $this->description; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(HardwareKeyMetadata::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_HardwareKeyMetadata'); Filter.php 0000644 00000003456 15253110636 0006514 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class Filter extends \WPMailSMTP\Vendor\Google\Model { protected $actionType = FilterAction::class; protected $actionDataType = ''; protected $criteriaType = FilterCriteria::class; protected $criteriaDataType = ''; /** * @var string */ public $id; /** * @param FilterAction */ public function setAction(FilterAction $action) { $this->action = $action; } /** * @return FilterAction */ public function getAction() { return $this->action; } /** * @param FilterCriteria */ public function setCriteria(FilterCriteria $criteria) { $this->criteria = $criteria; } /** * @return FilterCriteria */ public function getCriteria() { return $this->criteria; } /** * @param string */ public function setId($id) { $this->id = $id; } /** * @return string */ public function getId() { return $this->id; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(Filter::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Filter'); SmtpMsa.php 0000644 00000004450 15253110636 0006646 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class SmtpMsa extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $host; /** * @var string */ public $password; /** * @var int */ public $port; /** * @var string */ public $securityMode; /** * @var string */ public $username; /** * @param string */ public function setHost($host) { $this->host = $host; } /** * @return string */ public function getHost() { return $this->host; } /** * @param string */ public function setPassword($password) { $this->password = $password; } /** * @return string */ public function getPassword() { return $this->password; } /** * @param int */ public function setPort($port) { $this->port = $port; } /** * @return int */ public function getPort() { return $this->port; } /** * @param string */ public function setSecurityMode($securityMode) { $this->securityMode = $securityMode; } /** * @return string */ public function getSecurityMode() { return $this->securityMode; } /** * @param string */ public function setUsername($username) { $this->username = $username; } /** * @return string */ public function getUsername() { return $this->username; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(SmtpMsa::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_SmtpMsa'); Profile.php 0000644 00000004157 15253110636 0006666 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class Profile extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $emailAddress; /** * @var string */ public $historyId; /** * @var int */ public $messagesTotal; /** * @var int */ public $threadsTotal; /** * @param string */ public function setEmailAddress($emailAddress) { $this->emailAddress = $emailAddress; } /** * @return string */ public function getEmailAddress() { return $this->emailAddress; } /** * @param string */ public function setHistoryId($historyId) { $this->historyId = $historyId; } /** * @return string */ public function getHistoryId() { return $this->historyId; } /** * @param int */ public function setMessagesTotal($messagesTotal) { $this->messagesTotal = $messagesTotal; } /** * @return int */ public function getMessagesTotal() { return $this->messagesTotal; } /** * @param int */ public function setThreadsTotal($threadsTotal) { $this->threadsTotal = $threadsTotal; } /** * @return int */ public function getThreadsTotal() { return $this->threadsTotal; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(Profile::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_Profile'); LanguageSettings.php 0000644 00000002341 15253110636 0010523 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class LanguageSettings extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $displayLanguage; /** * @param string */ public function setDisplayLanguage($displayLanguage) { $this->displayLanguage = $displayLanguage; } /** * @return string */ public function getDisplayLanguage() { return $this->displayLanguage; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(LanguageSettings::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_LanguageSettings'); ModifyThreadRequest.php 0000644 00000003151 15253110636 0011207 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ModifyThreadRequest extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'removeLabelIds'; /** * @var string[] */ public $addLabelIds; /** * @var string[] */ public $removeLabelIds; /** * @param string[] */ public function setAddLabelIds($addLabelIds) { $this->addLabelIds = $addLabelIds; } /** * @return string[] */ public function getAddLabelIds() { return $this->addLabelIds; } /** * @param string[] */ public function setRemoveLabelIds($removeLabelIds) { $this->removeLabelIds = $removeLabelIds; } /** * @return string[] */ public function getRemoveLabelIds() { return $this->removeLabelIds; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ModifyThreadRequest::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ModifyThreadRequest'); PivKeyMetadata.php 0000644 00000002277 15253110636 0010137 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class PivKeyMetadata extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $description; /** * @param string */ public function setDescription($description) { $this->description = $description; } /** * @return string */ public function getDescription() { return $this->description; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(PivKeyMetadata::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_PivKeyMetadata'); ModifyMessageRequest.php 0000644 00000003154 15253110636 0011367 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ModifyMessageRequest extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'removeLabelIds'; /** * @var string[] */ public $addLabelIds; /** * @var string[] */ public $removeLabelIds; /** * @param string[] */ public function setAddLabelIds($addLabelIds) { $this->addLabelIds = $addLabelIds; } /** * @return string[] */ public function getAddLabelIds() { return $this->addLabelIds; } /** * @param string[] */ public function setRemoveLabelIds($removeLabelIds) { $this->removeLabelIds = $removeLabelIds; } /** * @return string[] */ public function getRemoveLabelIds() { return $this->removeLabelIds; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ModifyMessageRequest::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ModifyMessageRequest'); FilterAction.php 0000644 00000003573 15253110636 0007652 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class FilterAction extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'removeLabelIds'; /** * @var string[] */ public $addLabelIds; /** * @var string */ public $forward; /** * @var string[] */ public $removeLabelIds; /** * @param string[] */ public function setAddLabelIds($addLabelIds) { $this->addLabelIds = $addLabelIds; } /** * @return string[] */ public function getAddLabelIds() { return $this->addLabelIds; } /** * @param string */ public function setForward($forward) { $this->forward = $forward; } /** * @return string */ public function getForward() { return $this->forward; } /** * @param string[] */ public function setRemoveLabelIds($removeLabelIds) { $this->removeLabelIds = $removeLabelIds; } /** * @return string[] */ public function getRemoveLabelIds() { return $this->removeLabelIds; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(FilterAction::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_FilterAction'); ListSendAsResponse.php 0000644 00000002370 15253110636 0011011 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ListSendAsResponse extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'sendAs'; protected $sendAsType = SendAs::class; protected $sendAsDataType = 'array'; /** * @param SendAs[] */ public function setSendAs($sendAs) { $this->sendAs = $sendAs; } /** * @return SendAs[] */ public function getSendAs() { return $this->sendAs; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ListSendAsResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ListSendAsResponse'); AutoForwarding.php 0000644 00000003452 15253110636 0010216 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class AutoForwarding extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $disposition; /** * @var string */ public $emailAddress; /** * @var bool */ public $enabled; /** * @param string */ public function setDisposition($disposition) { $this->disposition = $disposition; } /** * @return string */ public function getDisposition() { return $this->disposition; } /** * @param string */ public function setEmailAddress($emailAddress) { $this->emailAddress = $emailAddress; } /** * @return string */ public function getEmailAddress() { return $this->emailAddress; } /** * @param bool */ public function setEnabled($enabled) { $this->enabled = $enabled; } /** * @return bool */ public function getEnabled() { return $this->enabled; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(AutoForwarding::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_AutoForwarding'); PopSettings.php 0000644 00000003000 15253110636 0007527 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class PopSettings extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $accessWindow; /** * @var string */ public $disposition; /** * @param string */ public function setAccessWindow($accessWindow) { $this->accessWindow = $accessWindow; } /** * @return string */ public function getAccessWindow() { return $this->accessWindow; } /** * @param string */ public function setDisposition($disposition) { $this->disposition = $disposition; } /** * @return string */ public function getDisposition() { return $this->disposition; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(PopSettings::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_PopSettings'); CseIdentity.php 0000644 00000004042 15253110636 0007503 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class CseIdentity extends \WPMailSMTP\Vendor\Google\Model { /** * @var string */ public $emailAddress; /** * @var string */ public $primaryKeyPairId; protected $signAndEncryptKeyPairsType = SignAndEncryptKeyPairs::class; protected $signAndEncryptKeyPairsDataType = ''; /** * @param string */ public function setEmailAddress($emailAddress) { $this->emailAddress = $emailAddress; } /** * @return string */ public function getEmailAddress() { return $this->emailAddress; } /** * @param string */ public function setPrimaryKeyPairId($primaryKeyPairId) { $this->primaryKeyPairId = $primaryKeyPairId; } /** * @return string */ public function getPrimaryKeyPairId() { return $this->primaryKeyPairId; } /** * @param SignAndEncryptKeyPairs */ public function setSignAndEncryptKeyPairs(SignAndEncryptKeyPairs $signAndEncryptKeyPairs) { $this->signAndEncryptKeyPairs = $signAndEncryptKeyPairs; } /** * @return SignAndEncryptKeyPairs */ public function getSignAndEncryptKeyPairs() { return $this->signAndEncryptKeyPairs; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(CseIdentity::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_CseIdentity'); ListThreadsResponse.php 0000644 00000003711 15253110636 0011226 0 ustar 00 <?php /* * Copyright 2014 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ namespace WPMailSMTP\Vendor\Google\Service\Gmail; class ListThreadsResponse extends \WPMailSMTP\Vendor\Google\Collection { protected $collection_key = 'threads'; /** * @var string */ public $nextPageToken; /** * @var string */ public $resultSizeEstimate; protected $threadsType = Thread::class; protected $threadsDataType = 'array'; /** * @param string */ public function setNextPageToken($nextPageToken) { $this->nextPageToken = $nextPageToken; } /** * @return string */ public function getNextPageToken() { return $this->nextPageToken; } /** * @param string */ public function setResultSizeEstimate($resultSizeEstimate) { $this->resultSizeEstimate = $resultSizeEstimate; } /** * @return string */ public function getResultSizeEstimate() { return $this->resultSizeEstimate; } /** * @param Thread[] */ public function setThreads($threads) { $this->threads = $threads; } /** * @return Thread[] */ public function getThreads() { return $this->threads; } } // Adding a class alias for backwards compatibility with the previous class name. \class_alias(ListThreadsResponse::class, 'WPMailSMTP\\Vendor\\Google_Service_Gmail_ListThreadsResponse'); Options.php 0000644 00000026364 15253213420 0006720 0 ustar 00 <?php namespace WPMailSMTP\Providers\Gmail; use WPMailSMTP\Admin\ConnectionSettings; use WPMailSMTP\ConnectionInterface; use WPMailSMTP\Helpers\UI; use WPMailSMTP\Providers\OptionsAbstract; /** * Class Option. * * @since 1.0.0 */ class Options extends OptionsAbstract { /** * Mailer slug. * * @since 1.5.0 */ const SLUG = 'gmail'; /** * Gmail Options constructor. * * @since 1.0.0 * @since 2.3.0 Added supports parameter. * * @param ConnectionInterface $connection The Connection object. */ public function __construct( $connection = null ) { parent::__construct( [ 'logo_url' => wp_mail_smtp()->assets_url . '/images/providers/google.svg', 'slug' => self::SLUG, 'title' => esc_html__( 'Google / Gmail', 'wp-mail-smtp' ), 'description' => sprintf( wp_kses( /* translators: %s - URL to our Gmail doc. */ __( 'Our Gmail mailer works with any Gmail or Google Workspace account via the Google API. You can send WordPress emails from your main email address or a Gmail alias, and it\'s more secure than connecting to Gmail using SMTP credentials. We now have a One-Click Setup, which simply asks you to authorize your Google account to use our app and takes care of everything for you. Alternatively, you can connect manually, which involves several steps that are more technical than other mailer options, so we created a detailed guide to walk you through the process.<br><br>To get started, read our <a href="%s" target="_blank" rel="noopener noreferrer">Gmail documentation</a>.', 'wp-mail-smtp' ), [ 'br' => [], 'a' => [ 'href' => [], 'rel' => [], 'target' => [], ], ] ), esc_url( wp_mail_smtp()->get_utm_url( 'https://wpmailsmtp.com/docs/how-to-set-up-the-gmail-mailer-in-wp-mail-smtp/', 'Gmail documentation' ) ) ), 'notices' => [ 'educational' => wp_kses( __( 'The Gmail mailer works well for sites that send low numbers of emails. However, Gmail\'s API has rate limitations and a number of additional restrictions that can lead to challenges during setup.<br><br>If you expect to send a high volume of emails, or if you find that your web host is not compatible with the Gmail API restrictions, then we recommend considering a different mailer option.', 'wp-mail-smtp' ), [ 'br' => [], ] ), ], 'php' => '5.6', 'supports' => [ 'from_email' => true, 'from_name' => true, 'return_path' => false, 'from_email_force' => true, 'from_name_force' => true, ], ], $connection ); } /** * @inheritdoc */ public function display_options() { // Do not display options if PHP version is not correct. if ( ! $this->is_php_correct() ) { $this->display_php_warning(); return; } ?> <?php if ( ! wp_mail_smtp()->is_pro() ) : ?> <div id="wp-mail-smtp-setting-row-<?php echo esc_attr( $this->get_slug() ); ?>-one_click_setup_enabled-lite" class="wp-mail-smtp-setting-row"> <div class="wp-mail-smtp-setting-label"> <label for="wp-mail-smtp-setting-<?php echo esc_attr( $this->get_slug() ); ?>-one_click_setup_enabled-lite"> <?php esc_html_e( 'One-Click Setup', 'wp-mail-smtp' ); ?> </label> </div> <div class="wp-mail-smtp-setting-field"> <?php UI::toggle( [ 'id' => 'wp-mail-smtp-setting-' . esc_attr( $this->get_slug() ) . '-one_click_setup_enabled-lite', ] ); ?> <p class="desc"> <?php esc_html_e( 'Provides a quick and easy way to connect to Google that doesn\'t require creating your own app.', 'wp-mail-smtp' ); ?> </p> </div> </div> <?php endif; ?> <!-- Client ID --> <div id="wp-mail-smtp-setting-row-<?php echo esc_attr( $this->get_slug() ); ?>-client_id" class="wp-mail-smtp-setting-row wp-mail-smtp-setting-row-text wp-mail-smtp-clear"> <div class="wp-mail-smtp-setting-label"> <label for="wp-mail-smtp-setting-<?php echo esc_attr( $this->get_slug() ); ?>-client_id"><?php esc_html_e( 'Client ID', 'wp-mail-smtp' ); ?></label> </div> <div class="wp-mail-smtp-setting-field"> <input name="wp-mail-smtp[<?php echo esc_attr( $this->get_slug() ); ?>][client_id]" type="text" value="<?php echo esc_attr( $this->connection_options->get( $this->get_slug(), 'client_id' ) ); ?>" <?php echo $this->connection_options->is_const_defined( $this->get_slug(), 'client_id' ) ? 'disabled' : ''; ?> id="wp-mail-smtp-setting-<?php echo esc_attr( $this->get_slug() ); ?>-client_id" spellcheck="false" /> </div> </div> <!-- Client Secret --> <div id="wp-mail-smtp-setting-row-<?php echo esc_attr( $this->get_slug() ); ?>-client_secret" class="wp-mail-smtp-setting-row wp-mail-smtp-setting-row-text wp-mail-smtp-clear"> <div class="wp-mail-smtp-setting-label"> <label for="wp-mail-smtp-setting-<?php echo esc_attr( $this->get_slug() ); ?>-client_secret"><?php esc_html_e( 'Client Secret', 'wp-mail-smtp' ); ?></label> </div> <div class="wp-mail-smtp-setting-field"> <?php if ( $this->connection_options->is_const_defined( $this->get_slug(), 'client_secret' ) ) : ?> <input type="text" disabled value="****************************************" id="wp-mail-smtp-setting-<?php echo esc_attr( $this->get_slug() ); ?>-client_secret" /> <?php $this->display_const_set_message( 'WPMS_GMAIL_CLIENT_SECRET' ); ?> <?php else : ?> <?php $slug = $this->get_slug(); $value = $this->connection_options->get( $this->get_slug(), 'client_secret' ); UI::hidden_password_field( [ 'name' => "wp-mail-smtp[{$slug}][client_secret]", 'id' => "wp-mail-smtp-setting-{$slug}-client_secret", 'value' => $value, 'clear_text' => esc_html__( 'Remove Client Secret', 'wp-mail-smtp' ), ] ); ?> <?php endif; ?> </div> </div> <!-- Authorized redirect URI --> <div id="wp-mail-smtp-setting-row-<?php echo esc_attr( $this->get_slug() ); ?>-client_redirect" class="wp-mail-smtp-setting-row wp-mail-smtp-setting-row-text wp-mail-smtp-clear"> <div class="wp-mail-smtp-setting-label"> <label for="wp-mail-smtp-setting-<?php echo esc_attr( $this->get_slug() ); ?>-client_redirect"><?php esc_html_e( 'Authorized redirect URI', 'wp-mail-smtp' ); ?></label> </div> <div class="wp-mail-smtp-setting-field"> <input type="text" readonly="readonly" onfocus="this.select();" value="<?php echo esc_attr( Auth::get_oauth_redirect_url() ); ?>" id="wp-mail-smtp-setting-<?php echo esc_attr( $this->get_slug() ); ?>-client_redirect" /> <button type="button" class="wp-mail-smtp-btn wp-mail-smtp-btn-md wp-mail-smtp-btn-grey wp-mail-smtp-setting-copy" title="<?php esc_attr_e( 'Copy URL to clipboard', 'wp-mail-smtp' ); ?>" data-source_id="wp-mail-smtp-setting-<?php echo esc_attr( $this->get_slug() ); ?>-client_redirect"> <span class="dashicons dashicons-admin-page"></span> </button> <p class="desc"> <?php esc_html_e( 'Please copy this URL into the "Authorized redirect URIs" field of your Google web application.', 'wp-mail-smtp' ); ?> </p> </div> </div> <!-- Auth users button --> <div id="wp-mail-smtp-setting-row-<?php echo esc_attr( $this->get_slug() ); ?>-authorize" class="wp-mail-smtp-setting-row wp-mail-smtp-setting-row-text wp-mail-smtp-clear"> <div class="wp-mail-smtp-setting-label"> <label><?php esc_html_e( 'Authorization', 'wp-mail-smtp' ); ?></label> </div> <div class="wp-mail-smtp-setting-field"> <?php $this->display_auth_setting_action(); ?> </div> </div> <?php } /** * Display either an "Allow..." or "Remove..." button. * * @since 1.3.0 */ protected function display_auth_setting_action() { // Do the processing on the fly, as having ajax here is too complicated. $this->process_provider_remove(); $auth = new Auth( $this->connection ); ?> <?php if ( $auth->is_clients_saved() ) : ?> <?php if ( $auth->is_auth_required() ) : ?> <a href="<?php echo esc_url( $auth->get_auth_url() ); ?>" class="wp-mail-smtp-btn wp-mail-smtp-btn-md wp-mail-smtp-btn-orange"> <?php esc_html_e( 'Allow plugin to send emails using your Google account', 'wp-mail-smtp' ); ?> </a> <p class="desc"> <?php esc_html_e( 'Click the button above to confirm authorization.', 'wp-mail-smtp' ); ?> </p> <?php else : ?> <a href="<?php echo esc_url( wp_nonce_url( ( new ConnectionSettings( $this->connection ) )->get_admin_page_url(), 'gmail_remove', 'gmail_remove_nonce' ) ); ?>#wp-mail-smtp-setting-row-<?php echo esc_attr( $this->get_slug() ); ?>-authorize" class="wp-mail-smtp-btn wp-mail-smtp-btn-md wp-mail-smtp-btn-red js-wp-mail-smtp-provider-remove"> <?php esc_html_e( 'Remove OAuth Connection', 'wp-mail-smtp' ); ?> </a> <span class="connected-as"> <?php $user = $auth->get_user_info(); if ( ! empty( $user['email'] ) ) { printf( /* translators: %s - email address, as received from Google API. */ esc_html__( 'Connected as %s', 'wp-mail-smtp' ), '<code>' . esc_html( $user['email'] ) . '</code>' ); } ?> </span> <p class="desc"> <?php printf( wp_kses( /* translators: %s - URL to Google Gmail alias documentation page. */ __( 'If you want to use a different From Email address you can set up a Google email alias. <a href="%s" target="_blank" rel="noopener noreferrer">Follow these instructions</a> and then select the From Email at the top of this page.', 'wp-mail-smtp' ), [ 'a' => [ 'href' => [], 'rel' => [], 'target' => [], ], ] ), esc_url( wp_mail_smtp()->get_utm_url( 'https://wpmailsmtp.com/gmail-send-from-alias-wp-mail-smtp/', 'Gmail aliases description - Follow these instructions' ) ) ); ?> </p> <p class="desc"> <?php esc_html_e( 'You can also send emails with different From Email addresses, by disabling the Force From Email setting and using registered aliases throughout your WordPress site as the From Email addresses.', 'wp-mail-smtp' ); ?> </p> <p class="desc"> <?php esc_html_e( 'Removing the OAuth connection will give you an ability to redo the OAuth connection or link to another Google account.', 'wp-mail-smtp' ); ?> </p> <?php endif; ?> <?php else : ?> <p class="inline-notice inline-error"> <?php esc_html_e( 'You need to save settings with Client ID and Client Secret before you can proceed.', 'wp-mail-smtp' ); ?> </p> <?php endif; } /** * Remove Provider OAuth connection. * * @since 1.3.0 */ public function process_provider_remove() { if ( ! current_user_can( wp_mail_smtp()->get_capability_manage_global_options() ) ) { return; } if ( ! isset( $_GET['gmail_remove_nonce'] ) || ! wp_verify_nonce( sanitize_key( $_GET['gmail_remove_nonce'] ), 'gmail_remove' ) ) { return; } if ( $this->connection->get_mailer_slug() !== $this->get_slug() ) { return; } $old_opt = $this->connection_options->get_all_raw(); unset( $old_opt[ $this->get_slug() ]['access_token'] ); unset( $old_opt[ $this->get_slug() ]['refresh_token'] ); unset( $old_opt[ $this->get_slug() ]['user_details'] ); unset( $old_opt[ $this->get_slug() ]['auth_code'] ); $this->connection_options->set( $old_opt ); } } Logger.php 0000644 00000007771 15253213420 0006505 0 ustar 00 <?php namespace WPMailSMTP\Providers\Gmail; use WPMailSMTP\Admin\DebugEvents\DebugEvents; use WPMailSMTP\Vendor\Psr\Log\LoggerInterface; use WPMailSMTP\Vendor\Psr\Log\LogLevel; /** * Custom logger for Gmail provider to replace Monolog dependency. * * @since 4.7.0 */ class Logger implements LoggerInterface { /** * System is unusable. * * @since 4.7.0 * * @param string $message The log message. * @param array $context The log context. */ public function emergency( $message, array $context = [] ) { $this->log( LogLevel::EMERGENCY, $message, $context ); } /** * Action must be taken immediately. * * @since 4.7.0 * * @param string $message The log message. * @param array $context The log context. */ public function alert( $message, array $context = [] ) { $this->log( LogLevel::ALERT, $message, $context ); } /** * Critical conditions. * * @since 4.7.0 * * @param string $message The log message. * @param array $context The log context. */ public function critical( $message, array $context = [] ) { $this->log( LogLevel::CRITICAL, $message, $context ); } /** * Runtime errors that do not require immediate action but should typically * be logged and monitored. * * @since 4.7.0 * * @param string $message The log message. * @param array $context The log context. */ public function error( $message, array $context = [] ) { $this->log( LogLevel::ERROR, $message, $context ); } /** * Exceptional occurrences that are not errors. * * @since 4.7.0 * * @param string $message The log message. * @param array $context The log context. */ public function warning( $message, array $context = [] ) { $this->log( LogLevel::WARNING, $message, $context ); } /** * Normal but significant events. * * @since 4.7.0 * * @param string $message The log message. * @param array $context The log context. */ public function notice( $message, array $context = [] ) { $this->log( LogLevel::NOTICE, $message, $context ); } /** * Interesting events. * * @since 4.7.0 * * @param string $message The log message. * @param array $context The log context. */ public function info( $message, array $context = [] ) { $this->log( LogLevel::INFO, $message, $context ); } /** * Detailed debug information. * * @since 4.7.0 * * @param string $message The log message. * @param array $context The log context. */ public function debug( $message, array $context = [] ) { $this->log( LogLevel::DEBUG, $message, $context ); } /** * Logs with an arbitrary level. * * @since 4.7.0 * * @param mixed $level The log level. * @param string $message The log message. * @param array $context The log context. */ public function log( $level, $message, array $context = [] ) { // Only log errors and warnings to avoid spam. if ( ! in_array( $level, [ LogLevel::ERROR, LogLevel::WARNING, LogLevel::CRITICAL, LogLevel::EMERGENCY, LogLevel::ALERT ], true ) ) { return; } // Interpolate context values into the message placeholders. $message = $this->interpolate( $message, $context ); // Format the log message. $formatted_message = sprintf( '[%s] Gmail API: %s', strtoupper( $level ), $message ); DebugEvents::add( $formatted_message ); } /** * Interpolates context values into the message placeholders. * * @since 4.7.0 * * @param string $message The message with placeholders. * @param array $context The context array. * * @return string The interpolated message. */ private function interpolate( $message, array $context = [] ) { // Build a replacement array with braces around the context keys. $replace = []; foreach ( $context as $key => $val ) { // Check that the value can be cast to string. if ( ! is_array( $val ) && ( ! is_object( $val ) || method_exists( $val, '__toString' ) ) ) { $replace[ '{' . $key . '}' ] = $val; } } // Interpolate replacement values into the message and return. return strtr( $message, $replace ); } } Mailer.php 0000644 00000021002 15253213420 0006456 0 ustar 00 <?php namespace WPMailSMTP\Providers\Gmail; use WPMailSMTP\Admin\DebugEvents\DebugEvents; use WPMailSMTP\Helpers\Helpers; use WPMailSMTP\MailCatcherInterface; use WPMailSMTP\Providers\MailerAbstract; use WPMailSMTP\Vendor\Google\Service\Gmail; use WPMailSMTP\Vendor\Google\Service\Gmail\Message; use WPMailSMTP\WP; /** * Class Mailer. * * @since 1.0.0 */ class Mailer extends MailerAbstract { /** * URL to make an API request to. * Not used for Gmail, as we are using its API. * * @since 1.0.0 * * @var string */ protected $url = 'https://www.googleapis.com/upload/gmail/v1/users/{userId}/messages/send'; /** * Gmail message. * * @since 1.0.0 * * @var Message */ protected $message; /** * Re-use the MailCatcher class methods and properties. * * @since 1.2.0 * * @param MailCatcherInterface $phpmailer The MailCatcher object. */ public function process_phpmailer( $phpmailer ) { // Make sure that we have access to PHPMailer class methods. if ( ! wp_mail_smtp()->is_valid_phpmailer( $phpmailer ) ) { return; } $this->phpmailer = $phpmailer; } /** * Use Google API Services to send emails. * * @since 1.0.0 */ public function send() { // Include the Google library. require_once wp_mail_smtp()->plugin_path . '/vendor/autoload.php'; $auth = new Auth( $this->connection ); $message = new Message(); // Set the authorized Gmail email address as the "from email" if the set email is not on the list of aliases. $possible_from_emails = $auth->get_user_possible_send_from_addresses(); if ( ! in_array( $this->phpmailer->From, $possible_from_emails, true ) ) { $user_info = $auth->get_user_info(); if ( ! empty( $user_info['email'] ) ) { $this->phpmailer->From = $user_info['email']; $this->phpmailer->Sender = $user_info['email']; } } try { // Prepare a message for sending if any changes happened above. $this->phpmailer->preSend(); // Get the raw MIME email using MailCatcher data. We need to make base64URL-safe string. $base64 = str_replace( [ '+', '/', '=' ], [ '-', '_', '' ], base64_encode( $this->phpmailer->getSentMIMEMessage() ) //phpcs:ignore ); $message->setRaw( $base64 ); $service = new Gmail( $auth->get_client() ); $response = $service->users_messages->send( 'me', $message ); DebugEvents::add_debug( esc_html__( 'An email request was sent to the Gmail API.', 'wp-mail-smtp' ) ); $this->process_response( $response ); } catch ( \Exception $e ) { $this->error_message = $this->process_exception_message( $e->getMessage() ); // Extract error code from Google API JSON response or exception code. $error_data = json_decode( $e->getMessage() ); if ( ! empty( $error_data->error ) && is_string( $error_data->error ) ) { $this->error_code = $error_data->error; } elseif ( $e->getCode() ) { $this->error_code = $e->getCode(); } } } /** * Save response from the API to use it later. * * @since 1.0.0 * @since 1.5.0 Added action "wp_mail_smtp_providers_gmail_mailer_process_response" with $response. * * @param Message $response Instance of Gmail response. */ protected function process_response( $response ) { $this->response = $response; if ( empty( $this->response ) || ! method_exists( $this->response, 'getId' ) ) { $this->error_message = esc_html__( 'The response object is invalid (missing getId method).', 'wp-mail-smtp' ); } else { $message_id = $this->response->getId(); if ( empty( $message_id ) ) { $this->error_message = esc_html__( 'The email message ID is missing.', 'wp-mail-smtp' ); } } do_action( 'wp_mail_smtp_providers_gmail_mailer_process_response', $this->response, $this->phpmailer ); } /** * Check whether the email was sent. * * @since 1.0.0 * * @return bool */ public function is_email_sent() { $is_sent = false; if ( ! empty( $this->response ) && method_exists( $this->response, 'getId' ) && ! empty( $this->response->getId() ) ) { $is_sent = true; } /** This filter is documented in src/Providers/MailerAbstract.php. */ return apply_filters( 'wp_mail_smtp_providers_mailer_is_email_sent', $is_sent, $this->mailer ); } /** * This method is relevant to SMTP and Pepipost. * All other custom mailers should override it with own information. * * @since 1.2.0 * * @return string */ public function get_debug_info() { // phpcs:ignore Generic.Metrics.CyclomaticComplexity.MaxExceeded $gmail_text = array(); $gmail = $this->connection_options->get_group( 'gmail' ); $curl_ver = 'No'; if ( function_exists( 'curl_version' ) ) { $curl = curl_version(); $curl_ver = $curl['version']; } $gmail_text[] = '<strong>Client ID/Secret:</strong> ' . ( ! empty( $gmail['client_id'] ) && ! empty( $gmail['client_secret'] ) ? 'Yes' : 'No' ); $gmail_text[] = '<strong>Auth Code:</strong> ' . ( ! empty( $gmail['auth_code'] ) ? 'Yes' : 'No' ); $gmail_text[] = '<strong>Access Token:</strong> ' . ( ! empty( $gmail['access_token'] ) ? 'Yes' : 'No' ); $gmail_text[] = '<br><strong>Server:</strong>'; $gmail_text[] = '<strong>OpenSSL:</strong> ' . ( extension_loaded( 'openssl' ) && defined( 'OPENSSL_VERSION_TEXT' ) ? OPENSSL_VERSION_TEXT : 'No' ); $gmail_text[] = '<strong>PHP.allow_url_fopen:</strong> ' . ( ini_get( 'allow_url_fopen' ) ? 'Yes' : 'No' ); $gmail_text[] = '<strong>PHP.stream_socket_client():</strong> ' . ( function_exists( 'stream_socket_client' ) ? 'Yes' : 'No' ); $gmail_text[] = '<strong>PHP.fsockopen():</strong> ' . ( function_exists( 'fsockopen' ) ? 'Yes' : 'No' ); $gmail_text[] = '<strong>PHP.curl_version():</strong> ' . $curl_ver; if ( function_exists( 'apache_get_modules' ) ) { $modules = apache_get_modules(); $gmail_text[] = '<strong>Apache.mod_security:</strong> ' . ( in_array( 'mod_security', $modules, true ) || in_array( 'mod_security2', $modules, true ) ? 'Yes' : 'No' ); } if ( function_exists( 'selinux_is_enabled' ) ) { $gmail_text[] = '<strong>OS.SELinux:</strong> ' . ( selinux_is_enabled() ? 'Yes' : 'No' ); } if ( function_exists( 'grsecurity_is_enabled' ) ) { $gmail_text[] = '<strong>OS.grsecurity:</strong> ' . ( grsecurity_is_enabled() ? 'Yes' : 'No' ); } return implode( '<br>', $gmail_text ); } /** * Whether the mailer has all its settings correctly set up and saved. * * @since 1.4.0 * * @return bool */ public function is_mailer_complete() { if ( ! $this->is_php_compatible() ) { return false; } $auth = new Auth( $this->connection ); if ( $auth->is_clients_saved() && ! $auth->is_auth_required() ) { return true; } return false; } /** * Process the exception message and append additional explanation to it. * * @since 2.1.0 * * @param mixed $message A string or an object with strings. * * @return string */ protected function process_exception_message( $message ) { // Transform the passed message to a string. if ( ! is_string( $message ) ) { $message = wp_json_encode( $message ); } else { $message = wp_strip_all_tags( $message, false ); } // Define known errors, that we will scan the message with. $known_errors = [ [ 'errors' => [ 'invalid_grant', ], 'explanation' => esc_html__( 'Please re-grant Google app permissions!', 'wp-mail-smtp' ) . ' ' . WP::EOL . esc_html__( 'Go to WP Mail SMTP plugin settings page. Click the “Remove OAuth Connection” button.', 'wp-mail-smtp' ) . ' ' . WP::EOL . esc_html__( 'Then click the “Allow plugin to send emails using your Google account” button and re-enable access.', 'wp-mail-smtp' ), ], ]; // Check if we get a match and append the explanation to the original message. foreach ( $known_errors as $error ) { foreach ( $error['errors'] as $error_fragment ) { if ( false !== strpos( $message, $error_fragment ) ) { return Helpers::format_error_message( $message, '', $error['explanation'] ); } } } // If we get no match we return the original message (as a string). return $message; } /** * Get the default email addresses for the reply to email parameter. * * @deprecated 2.1.1 * * @since 2.1.0 * @since 2.1.1 Not used anymore. * * @return array */ public function default_reply_to_addresses() { _deprecated_function( __CLASS__ . '::' . __METHOD__, '2.1.1 of WP Mail SMTP plugin' ); $gmail_creds = ( new Auth( $this->connection ) )->get_user_info(); if ( empty( $gmail_creds['email'] ) ) { return []; } return [ $gmail_creds['email'] => [ $gmail_creds['email'], '', ], ]; } } Auth.php 0000644 00000035051 15253213420 0006157 0 ustar 00 <?php namespace WPMailSMTP\Providers\Gmail; use Exception; use WP_Error; use WPMailSMTP\Admin\Area; use WPMailSMTP\Admin\ConnectionSettings; use WPMailSMTP\Admin\DebugEvents\DebugEvents; use WPMailSMTP\Admin\SetupWizard; use WPMailSMTP\ConnectionInterface; use WPMailSMTP\Providers\AuthAbstract; use WPMailSMTP\Providers\Gmail\Logger; use WPMailSMTP\Vendor\Google_Client; use WPMailSMTP\Vendor\Google\Service\Gmail; use WPMailSMTP\WP; /** * Class Auth to request access and refresh tokens. * * @since 1.0.0 */ class Auth extends AuthAbstract { /** * List of all possible "from email" email addresses (aliases). * * @since 2.2.0 * * @var null|array */ private $aliases = null; /** * Auth constructor. * * @since 1.0.0 * * @param ConnectionInterface $connection The Connection object. */ public function __construct( $connection = null ) { parent::__construct( $connection ); if ( $this->mailer_slug !== Options::SLUG ) { return; } $this->options = $this->connection_options->get_group( $this->mailer_slug ); if ( wp_mail_smtp()->is_pro() && ! empty( $this->options['one_click_setup_enabled'] ) ) { return; } if ( $this->is_clients_saved() ) { $this->include_vendor_lib(); $this->client = $this->get_client(); } } /** * Get the url, that users will be redirected back to finish the OAuth process. * * @since 1.5.2 Returned to the old, pre-1.5, structure of the link to preserve BC. * * @param ConnectionInterface $connection The Connection object. * * @return string */ public static function get_plugin_auth_url( $connection = null ) { if ( is_null( $connection ) ) { $connection = wp_mail_smtp()->get_connections_manager()->get_primary_connection(); } $auth_url = apply_filters( 'wp_mail_smtp_gmail_get_plugin_auth_url', add_query_arg( [ 'page' => Area::SLUG, 'tab' => 'auth', ], admin_url( 'options-general.php' ) ) ); return add_query_arg( 'state', self::get_state_param( $connection ), $auth_url ); } /** * Init and get the Google Client object. * * @since 1.0.0 * @since 1.5.0 Add ability to apply custom options to the client via a filter. * * @param bool $force If the client should be forcefully reinitialized. * * @return Google_Client */ public function get_client( $force = false ) { // Doesn't load client twice + gives ability to overwrite. if ( ! empty( $this->client ) && ! $force ) { return $this->client; } $this->include_vendor_lib(); $client = new Google_Client( [ 'client_id' => $this->options['client_id'], 'client_secret' => $this->options['client_secret'], 'redirect_uris' => [ self::get_oauth_redirect_url(), ], ] ); $client->setApplicationName( 'WP Mail SMTP v' . WPMS_PLUGIN_VER ); $client->setAccessType( 'offline' ); $client->setPrompt( 'consent' ); $client->setIncludeGrantedScopes( false ); // We request only the sending capability, as it's what we only need to do. $client->setScopes( [ Gmail::MAIL_GOOGLE_COM ] ); $client->setRedirectUri( self::get_oauth_redirect_url() ); // Set our custom logger to replace Monolog dependency. $client->setLogger( new Logger() ); if ( self::use_self_oauth_redirect_url() ) { $client->setState( self::get_state_param( $this->connection ) ); } else { $client->setState( self::get_plugin_auth_url( $this->connection ) ); } // Apply custom options to the client. $client = apply_filters( 'wp_mail_smtp_providers_gmail_auth_get_client_custom_options', $client ); $this->client = $client; if ( ! empty( $this->options['access_token'] ) ) { $this->client->setAccessToken( $this->options['access_token'] ); // Refresh expired token if needed. if ( $this->client->isAccessTokenExpired() ) { $this->refresh_access_token(); } } return $this->client; } /** * Try to get an access token using the authorization code grant. * * @since 4.9.0 * * @param string $code The authorization code returned by Google. * * @return WP_Error|true */ private function obtain_access_token( $code ) { if ( empty( $code ) ) { return true; } try { $creds = $this->client->fetchAccessTokenWithAuthCode( $code ); } catch ( Exception $e ) { $creds = [ 'error' => $e->getMessage() ]; } if ( ! empty( $creds['error'] ) ) { $error_message = $creds['error']; if ( $error_message === 'invalid_client' ) { $error_message .= PHP_EOL . esc_html__( 'Please make sure your Google Client ID and Secret in the plugin settings are valid. Save the settings and try the Authorization again.', 'wp-mail-smtp' ); } return new WP_Error( 'gmail_auth_failed', $error_message ); } $this->update_access_token( $this->client->getAccessToken() ); $this->update_refresh_token( $this->client->getRefreshToken() ); $this->update_user_details( $this->client ); // Update the "from email" to the connected user's email. if ( ! empty( $this->options['user_details']['email'] ) ) { $this->connection_options->set( [ 'mail' => [ 'from_email' => $this->options['user_details']['email'], ], ], false, false ); } return true; } /** * Refresh expired access token. * * Reads the refresh token from the SDK client's internal state (set by an earlier * setAccessToken call) or from options as a fallback. Bails silently when no * refresh token is available — the user will need to re-authorize. * * @since 4.9.0 */ private function refresh_access_token() { $refresh = $this->client->getRefreshToken(); if ( empty( $refresh ) && isset( $this->options['refresh_token'] ) ) { $refresh = $this->options['refresh_token']; } if ( empty( $refresh ) ) { return; } try { $creds = $this->client->fetchAccessTokenWithRefreshToken( $refresh ); } catch ( Exception $e ) { $creds = [ 'error' => $e->getMessage() ]; } if ( ! empty( $creds['error'] ) ) { DebugEvents::add_throttled( 'Mailer: Gmail' . WP::EOL . $creds['error'], 'gmail_refresh_error_' . $this->connection->get_id() ); return; } $this->update_access_token( $this->client->getAccessToken() ); $this->update_refresh_token( $this->client->getRefreshToken() ); } /** * Get the auth code from the $_GET and save it. * Redirect user back to settings with an error message, if failed. * * @since 1.0.0 */ public function process() { // phpcs:ignore Generic.Metrics.CyclomaticComplexity.MaxExceeded $redirect_url = ( new ConnectionSettings( $this->connection ) )->get_admin_page_url(); $is_setup_wizard_auth = ! empty( $this->options['is_setup_wizard_auth'] ); if ( $is_setup_wizard_auth ) { $this->update_is_setup_wizard_auth( false ); $redirect_url = SetupWizard::get_site_url() . '#/step/configure_mailer/gmail'; } if ( ! ( isset( $_GET['tab'] ) && $_GET['tab'] === 'auth' ) ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended wp_safe_redirect( $redirect_url ); exit; } $state = isset( $_GET['state'] ) ? sanitize_key( $_GET['state'] ) : false; if ( empty( $state ) ) { wp_safe_redirect( add_query_arg( 'error', 'oauth_invalid_state', $redirect_url ) ); exit; } list( $nonce ) = array_pad( explode( '-', $state ), 1, false ); // Verify the nonce that should be returned in the state parameter. if ( ! wp_verify_nonce( $nonce, $this->state_key ) ) { wp_safe_redirect( add_query_arg( 'error', 'google_invalid_nonce', $redirect_url ) ); exit; } // We can't process without saved client_id/secret. if ( ! $this->is_clients_saved() ) { wp_safe_redirect( add_query_arg( 'error', 'google_no_clients', $redirect_url ) ); exit; } $this->include_vendor_lib(); $code = ''; $scope = ''; $error = ''; if ( isset( $_GET['error'] ) ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended $error = sanitize_key( $_GET['error'] ); // phpcs:ignore WordPress.Security.NonceVerification.Recommended } // In case of any error: display a message to a user. if ( ! empty( $error ) ) { DebugEvents::add_debug( sprintf( /* Translators: %s the error code passed from Google. */ esc_html__( 'There was an error while processing Google authorization: %s', 'wp-mail-smtp' ), esc_html( $error ) ) ); wp_safe_redirect( add_query_arg( 'error', 'google_' . $error, $redirect_url ) ); exit; } if ( isset( $_GET['code'] ) ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended, WordPress.Security.ValidatedSanitizedInput.MissingUnslash, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized $code = urldecode( $_GET['code'] ); } if ( isset( $_GET['scope'] ) ) { // phpcs:ignore WordPress.Security.NonceVerification.Recommended, WordPress.Security.ValidatedSanitizedInput.MissingUnslash, WordPress.Security.ValidatedSanitizedInput.InputNotSanitized $scope = $_GET['scope']; if ( self::use_self_oauth_redirect_url() ) { $scope = urldecode( $scope ); } else { // phpcs:ignore WordPress.PHP.DiscouragedPHPFunctions.obfuscation_base64_decode $scope = urldecode( base64_decode( $scope ) ); } } // Validate code + scope. $scope_is_valid = ( $scope === Gmail::MAIL_GOOGLE_COM . ' ' . Gmail::GMAIL_SEND || $scope === Gmail::GMAIL_SEND . ' ' . Gmail::MAIL_GOOGLE_COM || $scope === Gmail::GMAIL_SEND || $scope === Gmail::MAIL_GOOGLE_COM ); if ( empty( $code ) || ! $scope_is_valid ) { DebugEvents::add_debug( esc_html__( 'There was an error while processing Google authorization: missing code or scope parameter.', 'wp-mail-smtp' ) ); wp_safe_redirect( add_query_arg( 'error', 'google_no_code_scope', $redirect_url ) ); exit; } // Ensure the SDK client is initialized. $this->get_client(); // Exchange the auth code for an access token. $result = $this->obtain_access_token( $code ); if ( $result instanceof WP_Error ) { $event_id = DebugEvents::add( 'Mailer: Gmail' . WP::EOL . $result->get_error_message() ); wp_safe_redirect( add_query_arg( [ 'error' => 'google_unsuccessful_oauth', 'debug_event_id' => $event_id, ], $redirect_url ) ); exit; } wp_safe_redirect( add_query_arg( 'success', 'google_site_linked', $redirect_url ) ); exit; } /** * Get the auth URL used to proceed to Provider to request access to send emails. * * @since 1.0.0 * * @return string */ public function get_auth_url() { if ( ! empty( $this->client ) && class_exists( 'WPMailSMTP\Vendor\Google_Client', false ) && $this->client instanceof Google_Client ) { return filter_var( $this->client->createAuthUrl(), FILTER_SANITIZE_URL ); } return '#'; } /** * Get and update user-related details (currently only email). * * @since 3.11.0 * * @param Google_Client $client The Google Client object (optional). */ private function update_user_details( $client = false ) { if ( $client === false ) { $client = $this->get_client(); } $gmail = new Gmail( $client ); try { $email = $gmail->users->getProfile( 'me' )->getEmailAddress(); $user_details = [ 'email' => $email, ]; // To save in DB. $updated_settings = [ $this->mailer_slug => [ 'user_details' => $user_details, ], ]; // To save in currently retrieved options array. $this->options['user_details'] = $user_details; $this->connection_options->set( $updated_settings, false, false ); } catch ( Exception $e ) { // phpcs:ignore Generic.CodeAnalysis.EmptyStatement.DetectedCatch // Do nothing. } } /** * Get user information (currently only email) that is associated with the current OAuth connection. * * @since 1.5.0 * @since 3.11.0 Switched to DB stored value instead of API call. * * @return array */ public function get_user_info() { /* * We need to populate user data on the fly for old users who already performed * authorization before we switched to DB stored value. */ if ( ! isset( $this->options['user_details'] ) && ! $this->is_auth_required() ) { $this->update_user_details(); } return $this->connection_options->get( $this->mailer_slug, 'user_details' ); } /** * Get the registered email addresses that the user can use as the "from email". * * @since 2.2.0 * * @return array The list of possible from email addresses. */ public function get_user_possible_send_from_addresses() { if ( isset( $this->aliases ) ) { return $this->aliases; } $gmail = new Gmail( $this->get_client() ); try { // phpcs:ignore WordPress.NamingConventions.ValidVariableName.UsedPropertyNotSnakeCase $response = $gmail->users_settings_sendAs->listUsersSettingsSendAs( 'me' ); // phpcs:disable $this->aliases = array_map( function( $sendAsObject ) { return $sendAsObject['sendAsEmail']; }, (array) $response->getSendAs() ); // phpcs:enable } catch ( Exception $exception ) { DebugEvents::add_debug( sprintf( /* Translators: %s the error message. */ esc_html__( 'An error occurred when trying to get Gmail aliases: %s', 'wp-mail-smtp' ), esc_html( $exception->getMessage() ) ) ); $this->aliases = []; } return $this->aliases; } /** * Get the Google oAuth 2.0 redirect URL. * * This is the URL that Google will redirect after the access to the Gmail account is granted or rejected. * The below endpoint will then redirect back to the user's WP site (to self::get_plugin_auth_url() URL). * * @since 2.5.0 * * @return string */ public static function get_oauth_redirect_url() { if ( self::use_self_oauth_redirect_url() ) { return remove_query_arg( 'state', self::get_plugin_auth_url() ); } else { return 'https://connect.wpmailsmtp.com/google/'; } } /** * Get the state parameter for the Google oAuth redirect URL. * * @since 3.10.0 * * @param ConnectionInterface $connection The Connection object. * * @return string */ private static function get_state_param( $connection ) { $state = [ wp_create_nonce( 'wp_mail_smtp_provider_client_state' ), $connection->get_id(), ]; return implode( '-', $state ); } /** * Whether to use self website redirect URL for the Google oAuth. * * @since 3.10.0 * * @return bool */ private static function use_self_oauth_redirect_url() { /** * Filter whether to use self website redirect URL for the Google oAuth. * * @since 3.10.0 * * @param bool $use Whether to use self website redirect URL for the Google oAuth. */ return apply_filters( 'wp_mail_smtp_providers_gmail_auth_use_self_oauth_redirect_url', false ); } }
dvadf
dvadf
| ver. 1.4 |
Github
|
.
| PHP 7.3.33 | Generation time: 0.01 |
proxy
|
phpinfo
|
Settings