Documentation

Application

Interfaces

AwsClientInterface: Interface that all AWS clients implement
CredentialsInterface: Provides access to the AWS credentials used for accessing AWS services: AWS access key ID, secret access key, and security token. These credentials are used to securely sign requests to AWS services.
AwsExceptionInterface: "Marker Interface" implemented by every exception in the AWS SDK
ExceptionFactoryInterface: Interface used to create AWS exception
ExceptionParserInterface: Interface used to parse exceptions into an associative array of data
FacadeInterface: Interface that defines a client facade. Facades are convenient static classes that allow you to run client methods statically on a default instance from the service builder. The facades themselves are aliased into the global namespace for ease of use.
ChunkHashInterface: Interface for objects that encapsulate the creation of a hash from streamed chunks of data
TransferInterface: Interface for transferring the contents of a data source to an AWS service via a multipart upload interface
TransferStateInterface: State of a multipart upload
UploadIdInterface: An object that encapsulates the data identifying an upload
UploadPartInterface: An object that encapsulates the data for an upload part
EndpointSignatureInterface: Interface for signatures that use specific region and service names when signing requests.
SignatureInterface: Interface used to provide interchangeable strategies for signing requests using the various AWS signature protocols.
ResourceWaiterInterface: Interface used in conjunction with clients to wait on a resource
WaiterFactoryInterface: Waiter factory used to create waiter objects by short names
WaiterInterface: WaiterInterface used to wait on something to be in a particular state
S3SignatureInterface: Interface used to provide interchangeable strategies for signing requests using the various AWS signature protocols.
FilenameConverterInterface: Converts filenames from one system to another (e.g. local to Amazon S3)
BatchDivisorInterface: Interface used for dividing a queue of items into an array of batches
BatchInterface: Interface for efficiently transferring items in a queue using batches
BatchTransferInterface: Interface used for transferring batches of items
GuzzleException: Guzzle exception
FromConfigInterface: Interfaces that adds a factory method which is used to instantiate a class from an array of configuration options.
HasDispatcherInterface: Holds an event dispatcher
ToArrayInterface: An object that can be represented as an array
ClientInterface: Client interface for send HTTP requests
CurlMultiInterface: Interface for sending a pool of {@see RequestInterface} objects in parallel
EntityBodyInterface: Entity body used with an HTTP request or response
HttpException: Http exception interface
EntityEnclosingRequestInterface: HTTP request that sends an entity-body in the request message (POST, PUT)
HeaderFactoryInterface: Interface for creating headers
HeaderInterface: An object that can be represented as an array
MessageInterface: Request and response message interface
PostFileInterface: POST file upload
RequestFactoryInterface: Request factory used to create HTTP requests
RequestInterface: Generic HTTP request interface
QueryAggregatorInterface: Interface used for aggregating nested query string variables into a flattened array of key value pairs
InflectorInterface: Inflector interface used to convert the casing of words
LogAdapterInterface: Adapter class that allows Guzzle to log data to various logging implementations.
CookieParserInterface: Cookie parser interface
MessageParserInterface: HTTP message parser interface used to parse HTTP messages into an array
UriTemplateInterface: Expands URI templates using an array of variables
UrlParserInterface: URL parser interface
BackoffStrategyInterface: Strategy to determine if a request should be retried and how long to delay between retries
CookieJarInterface: Interface for persisting cookies
ErrorResponseExceptionInterface: Interface used to create an exception from an error response
ServiceBuilderInterface: Service builder used to store and build clients or arbitrary data. Client configuration data can be supplied to tell the service builder how to create and cache {@see \Guzzle\Service\ClientInterface} objects. Arbitrary data can be supplied and accessed from a service builder. Arbitrary data and other clients can be referenced by name in client configuration arrays to make them input for building other clients (e.g. "{key}").
ClientInterface: Client interface for executing commands on a web service.
CommandInterface: A command object that contains parameters that can be modified and accessed like an array and turned into an array
FactoryInterface: Interface for creating commands by name
RequestVisitorInterface: Location visitor used to add values to different locations in a request with different behaviors as needed
ResponseVisitorInterface: Location visitor used to parse values out of a response into an associative array
RequestSerializerInterface: Translates command options and operation parameters into a request object
ResponseClassInterface: Interface used to accept a completed OperationCommand and parse the result into a specific response type
ResponseParserInterface: Parses the HTTP response of a command and sets the appropriate result on a command object
ConfigLoaderInterface: Interface used for loading configuration data (service descriptions, service builder configs, etc)
OperationInterface: Interface defining data objects that hold the information of an API operation
ServiceDescriptionInterface: A ServiceDescription stores service information based on a service document
ValidatorInterface: Validator responsible for preparing and validating parameters against the parameter's schema
ResourceIteratorFactoryInterface: Factory for creating {@see ResourceIteratorInterface} objects
ResourceIteratorInterface: Iterates over a paginated resource using subsequent requests in order to retrieve the entire matching result set
StreamInterface: OO interface to PHP streams
StreamRequestFactoryInterface: Interface used for creating streams from requests
LoggerAwareInterface: Describes a logger-aware instance
LoggerInterface: Describes a logger instance
TraceableEventDispatcherInterface: The EventDispatcherInterface is the central point of Symfony's event listener system.
EventDispatcherInterface: The EventDispatcherInterface is the central point of Symfony's event listener system.
EventSubscriberInterface: An EventSubscriber knows himself what events he is interested in.
JWTExceptionWithPayloadInterface
Google_Task_Retryable: Interface for checking how many times a given task can be retried following a failure.
Retryable: Interface for checking how many times a given task can be retried following a failure.
FetchAuthTokenInterface: An interface implemented by objects that can fetch auth tokens.
GetQuotaProjectInterface: An interface implemented by objects that can get quota projects.
ProjectIdProviderInterface: Describes a Credentials object which supports fetching the project ID.
SignBlobInterface: Describes a class which supports signing arbitrary strings.
UpdateMetadataInterface: Describes a Credentials object which supports updating request metadata (request headers).
ClientInterface: Client interface for sending HTTP requests.
CookieJarInterface: Stores HTTP cookies.
GuzzleException
CurlFactoryInterface
PromiseInterface: A promise represents the eventual result of an asynchronous operation.
PromisorInterface: Interface used with classes that return a promise.
TaskQueueInterface
FormatterInterface: Interface for formatters
ActivationStrategyInterface: Interface for activation strategies for the FingersCrossedHandler.
FormattableHandlerInterface: Interface to describe loggers that have a formatter
HandlerInterface: Interface that all Monolog Handlers must implement
ProcessableHandlerInterface: Interface to describe loggers that have processors
ProcessorInterface: An optional interface to allow labelling Monolog processors.
ResettableInterface: Handler or Processor implementing this interface will be reset when Logger::reset() is called.
CacheException: Exception interface for all exceptions thrown by an Implementing Library.
CacheItemInterface: CacheItemInterface defines an interface for interacting with objects inside a cache.
CacheItemPoolInterface: CacheItemPoolInterface generates CacheItemInterface objects.
InvalidArgumentException: Exception interface for invalid cache arguments.
MessageInterface: HTTP messages consist of requests from a client to a server and responses from a server to a client. This interface defines the methods common to each.
RequestInterface: Representation of an outgoing, client-side request.
ResponseInterface: Representation of an outgoing, server-side response.
ServerRequestInterface: Representation of an incoming, server-side HTTP request.
StreamInterface: Describes a data stream.
UploadedFileInterface: Value object representing a file uploaded through an HTTP request.
UriInterface: Value object representing a URI.
LoggerAwareInterface: Describes a logger-aware instance.
LoggerInterface: Describes a logger instance.
SessionUpdateTimestampHandlerInterface

Classes

HtmlDiff
Detail
Operation
EasyBlogFacebookApiException: Thrown when an API call returns an exception.
EasyBlogBaseFacebook: Provides access to the Facebook Platform. This class provides a majority of the functionality needed, but the class is abstract because it is designed to be sub-classed. The subclass must implement the four abstract methods listed at the bottom of the file.
EasyBlogFacebookConsumer: Extends the BaseFacebook class with the intent of using PHP sessions to store user ids and access tokens.
FlickrOauth
EasyBlogTwitterOAuth
Aws: Base class for interacting with web service clients
AbstractClient: Abstract AWS client
ClientBuilder: Builder for creating AWS service clients
DefaultClient: Generic client for interacting with an AWS service
ExpiredCredentialsChecker: Backoff logic that handles retrying requests when credentials expire
ThrottlingErrorChecker: Backoff logic that handles throttling exceptions from services
UploadBodyListener: Prepares the body parameter of a command such that the parameter is more flexible (e.g. accepts file handles) with the value it accepts but converts it to the correct format for the command. Also looks for a "Filename" parameter.
UserAgentListener: Listener used to append strings to the User-Agent header of a request based on the `ua.append` option. `ua.append` can contain a string or array of values.
AwsQueryVisitor: Location visitor used to serialize AWS query parameters (e.g. EC2, SES, SNS, SQS, etc) as POST fields
JsonCommand: Adds AWS JSON body functionality to dynamically generated HTTP requests
QueryCommand: Adds AWS Query service serialization
XmlResponseLocationVisitor: Class used for custom AWS XML response parsing of query services
AbstractCredentialsDecorator: Abstract credentials decorator
AbstractRefreshableCredentials: Abstract decorator to provide a foundation for refreshable credentials
CacheableCredentials: Credentials decorator used to implement caching credentials
Credentials: Basic implementation of the AWSCredentials interface that allows callers to pass in the AWS access key and secret access in the constructor.
NullCredentials: A blank set of credentials. AWS clients must be provided credentials, but there are some types of requests that do not need authentication. This class can be used to pivot on that scenario, and also serve as a mock credentials object when testing
RefreshableInstanceProfileCredentials: Credentials decorator used to implement retrieving credentials from the EC2 metadata server
ClientOptions: Contains enumerable default factory options that can be passed to a client's factory method
DateFormat: Contains enumerable date format values used in the SDK
Region: Contains enumerable region code values. These should be useful in most cases, with Amazon S3 being the most notable exception
Size: Contains enumerable byte-size values
Time: Contains enumerable time values
UaString: User-Agent header strings for various high level operations
Enum: Represents an enumerable set of values
BadMethodCallException: AWS SDK namespaced version of the SPL BadMethodCallException.
DomainException: AWS SDK namespaced version of the SPL DomainException.
ExceptionListener: Converts generic Guzzle response exceptions into AWS specific exceptions
InstanceProfileCredentialsException: Exception thrown when an error occurs with instance profile credentials
InvalidArgumentException: AWS SDK namespaced version of the SPL InvalidArgumentException.
LogicException: AWS SDK namespaced version of the SPL LogicException.
MultipartUploadException: Thrown when a {@see Aws\Common\MultipartUpload\TransferInterface} object encounters an error during transfer
NamespaceExceptionFactory: Attempts to create exceptions by inferring the name from the code and a base namespace that contains exceptions. Exception classes are expected to be in upper camelCase and always end in 'Exception'. 'Exception' will be appended if it is not present in the exception code.
OutOfBoundsException: AWS SDK namespaced version of the SPL OverflowException.
OverflowException: AWS SDK namespaced version of the SPL OverflowException.
AbstractJsonExceptionParser: Parses JSON encoded exception responses
DefaultXmlExceptionParser: Parses default XML exception responses
JsonQueryExceptionParser: Parses JSON encoded exception responses from query services
JsonRestExceptionParser: Parses JSON encoded exception responses from REST services
RequiredExtensionNotLoadedException: Thrown when a particular PHP extension is required to execute the guarded logic, but the extension is not loaded
RuntimeException: AWS SDK namespaced version of the SPL RuntimeException.
ServiceResponseException: Default AWS exception
TransferException: Transfer request exception
UnexpectedValueException: AWS SDK namespaced version of the SPL UnexpectedValueException.
AutoScaling: The following classes are used to implement the static client facades and are aliased into the global namespaced. We discourage the use of these classes directly by their full namespace since they are not autoloaded and are considered an implementation detail that could possibly be changed in the future.
CloudFormation: Base facade class that handles the delegation logic
CloudFront: Base facade class that handles the delegation logic
CloudSearch: Base facade class that handles the delegation logic
CloudTrail: Base facade class that handles the delegation logic
CloudWatch: Base facade class that handles the delegation logic
DataPipeline: Base facade class that handles the delegation logic
DirectConnect: Base facade class that handles the delegation logic
DynamoDb: Base facade class that handles the delegation logic
Ec2: Base facade class that handles the delegation logic
ElastiCache: Base facade class that handles the delegation logic
ElasticBeanstalk: Base facade class that handles the delegation logic
ElasticLoadBalancing: Base facade class that handles the delegation logic
ElasticTranscoder: Base facade class that handles the delegation logic
Emr: Base facade class that handles the delegation logic
Glacier: Base facade class that handles the delegation logic
Iam: Base facade class that handles the delegation logic
ImportExport: Base facade class that handles the delegation logic
Kinesis: Base facade class that handles the delegation logic
OpsWorks: Base facade class that handles the delegation logic
Rds: Base facade class that handles the delegation logic
Redshift: Base facade class that handles the delegation logic
Route53: Base facade class that handles the delegation logic
S3: Base facade class that handles the delegation logic
SimpleDb: Base facade class that handles the delegation logic
Ses: Base facade class that handles the delegation logic
Sns: Base facade class that handles the delegation logic
Sqs: Base facade class that handles the delegation logic
StorageGateway: Base facade class that handles the delegation logic
Sts: Base facade class that handles the delegation logic
Support: Base facade class that handles the delegation logic
Swf: Base facade class that handles the delegation logic
Facade: Base facade class that handles the delegation logic
ChunkHash: Encapsulates the creation of a hash from streamed chunks of data
HashUtils: Contains hashing utilities
TreeHash: Encapsulates the creation of a tree hash from streamed chunks of data
HostNameUtils: Utility class for parsing regions and services from URLs
InstanceMetadataClient: Client used for interacting with the Amazon EC2 instance metadata server
ServiceAvailable: Waits until the instance metadata service is responding. Will send up to 4 requests with a 5 second delay between each try. Each try can last up to 11 seconds to complete if the service is not responding.
AwsResourceIterator: Iterate over a client command
AwsResourceIteratorFactory: Resource iterator factory used to instantiate the default AWS resource iterator with the correct configuration or use a concrete iterator class if one exists
AbstractTransfer: Abstract class for transfer commonalities
AbstractTransferState: State of a multipart upload
AbstractUploadBuilder: Easily create a multipart uploader used to quickly and reliably upload a large file or data stream to Amazon S3 using multipart uploads
AbstractUploadId: An object that encapsulates the data identifying an upload
AbstractUploadPart: An object that encapsulates the data for an upload part
RulesEndpointProvider: Provides endpoints based on a rules configuration file.
AbstractSignature
SignatureListener: Listener used to sign requests before they are sent over the wire
SignatureV2: Implementation of Signature Version 2
SignatureV3Https: Implementation of Signature Version 3 HTTPS
SignatureV4: Signature Version 4
AbstractResourceWaiter: Abstract waiter implementation used to wait on resources
AbstractWaiter: Abstract wait implementation
CallableWaiter: Callable wait implementation
CompositeWaiterFactory: Factory that utilizes multiple factories for creating waiters
ConfigResourceWaiter: Resource waiter driven by configuration options
WaiterClassFactory: Factory for creating {@see WaiterInterface} objects using a convention of storing waiter classes in the Waiter folder of a client class namespace using a snake_case to CamelCase conversion (e.g. camel_case => CamelCase).
WaiterConfig: Configuration info of a waiter object
WaiterConfigFactory: Factory for creating {@see WaiterInterface} objects using a configuration DSL.
AcpListener: Listener used to add an Access Control Policy to a request
BucketStyleListener: Listener used to change the way in which buckets are referenced (path/virtual style) based on context
S3Command: Adds functionality to Amazon S3 commands: - Adds the PutObject URL to a response - Allows creating a Pre-signed URL from any command
CannedAcl: Contains enumerable CannedAcl values
EncodingType: Contains enumerable EncodingType values
Event: Contains enumerable Event values
GranteeType: Contains enumerable GranteeType values
Group: Contains enumerable Amazon S3 group options for ACL grantees
MetadataDirective: Contains enumerable MetadataDirective values
MFADelete: Contains enumerable MFADelete values
Payer: Contains enumerable Payer values
Permission: Contains enumerable Permission values
Protocol: Contains enumerable Protocol values
ServerSideEncryption: Contains enumerable ServerSideEncryption values
Status: Contains enumerable Status values
Storage: Contains enumerable Amazon S3 storage options
StorageClass: Contains enumerable StorageClass values
AccessDeniedException: Access Denied
AccountProblemException: There is a problem with your AWS account that prevents the operation from completing successfully. Please use Contact Us.
AmbiguousGrantByEmailAddressException: The e-mail address you provided is associated with more than one account.
BadDigestException: The Content-MD5 you specified did not match what we received.
BucketAlreadyExistsException: The requested bucket name is not available. The bucket namespace is shared by all users of the system. Please select a different name and try again.
BucketAlreadyOwnedByYouException: Your previous request to create the named bucket succeeded and you already own it.
BucketNotEmptyException: The bucket you tried to delete is not empty.
CredentialsNotSupportedException: This request does not support credentials.
CrossLocationLoggingProhibitedException: Cross location logging not allowed. Buckets in one geographic location cannot log information to a bucket in another location.
DeleteMultipleObjectsException: Exception thrown when errors occur in a DeleteMultipleObjects request
EntityTooLargeException: Your proposed upload exceeds the maximum allowed object size.
EntityTooSmallException: Your proposed upload is smaller than the minimum allowed object size.
ExpiredTokenException: The provided token has expired.
IllegalVersioningConfigurationException: Indicates that the Versioning configuration specified in the request is invalid.
IncompleteBodyException: You did not provide the number of bytes specified by the Content-Length HTTP header
IncorrectNumberOfFilesInPostRequestException: POST requires exactly one file upload per request.
InlineDataTooLargeException: Inline data exceeds the maximum allowed size.
InternalErrorException: We encountered an internal error. Please try again.
InvalidAccessKeyIdException: The AWS Access Key Id you provided does not exist in our records.
InvalidAddressingHeaderException: You must specify the Anonymous role.
InvalidArgumentException: Invalid Argument
InvalidBucketNameException: The specified bucket is not valid.
InvalidBucketStateException: The request is not valid with the current state of the bucket.
InvalidDigestException: The Content-MD5 you specified was an invalid.
InvalidLocationConstraintException: The specified location constraint is not valid. For more information about Regions, see How to Select a Region for Your Buckets.
InvalidPartException: One or more of the specified parts could not be found. The part might not have been uploaded, or the specified entity tag might not have matched the part's entity tag.
InvalidPartOrderException: The list of parts was not in ascending order.Parts list must specified in order by part number.
InvalidPayerException: All access to this object has been disabled.
InvalidPolicyDocumentException: The content of the form does not meet the conditions specified in the policy document.
InvalidRangeException: The requested range cannot be satisfied.
InvalidRequestException: SOAP requests must be made over an HTTPS connection.
InvalidSecurityException: The provided security credentials are not valid.
InvalidSOAPRequestException: The SOAP request body is invalid.
InvalidStorageClassException: The storage class you specified is not valid.
InvalidTagErrorException: The Tag provided was not a valid tag. This can occur if the Tag did not pass input validation. See the CostAllocation docs for a description of valid tags.
InvalidTargetBucketForLoggingException: The target bucket for logging does not exist, is not owned by you, or does not have the appropriate grants for the log-delivery group.
InvalidTokenException: The provided token is malformed or otherwise invalid.
InvalidURIException: Couldn't parse the specified URI.
KeyTooLongException: Your key is too long.
MalformedACLErrorException: The XML you provided was not well-formed or did not validate against our published schema.
MalformedPOSTRequestException: The body of your POST request is not well-formed multipart/form-data.
MalformedXMLException: This happens when the user sends a malformed xml (xml that doesn't conform to the published xsd) for the configuration. The error message is, "The XML you provided was not well-formed or did not validate against our published schema."
MaxMessageLengthExceededException: Your request was too big.
MaxPostPreDataLengthExceededErrorException: Your POST request fields preceding the upload file were too large.
MetadataTooLargeException: Your metadata headers exceed the maximum allowed metadata size.
MethodNotAllowedException: The specified method is not allowed against this resource.
MissingAttachmentException: A SOAP attachment was expected, but none were found.
MissingContentLengthException: You must provide the Content-Length HTTP header.
MissingRequestBodyErrorException: This happens when the user sends an empty xml document as a request. The error message is, "Request body is empty."
MissingSecurityElementException: The SOAP 1.1 request is missing a security element.
MissingSecurityHeaderException: Your request was missing a required header.
NoLoggingStatusForKeyException: There is no such thing as a logging status sub-resource for a key.
NoSuchBucketException: The specified bucket does not exist.
NoSuchBucketPolicyException: The specified bucket policy does not exist.
NoSuchCORSConfigurationException: The specified bucket does not have a CORs configuration.
NoSuchKeyException: The specified key does not exist.
NoSuchLifecycleConfigurationException: The lifecycle configuration does not exist.
NoSuchTagSetException: There is no TagSet associated with the bucket.
NoSuchUploadException: The specified multipart upload does not exist.
NoSuchVersionException: Indicates that the version ID specified in the request does not match an existing version.
NoSuchWebsiteConfigurationException: The specified bucket does not have a website configuration.
NotImplementedException: A header you provided implies functionality that is not implemented.
NotSignedUpException: Your account is not signed up for the Amazon S3 service. You must sign up before you can use Amazon S3. You can sign up at the following URL: http://aws.amazon.com/s3
NotSuchBucketPolicyException: The specified bucket does not have a bucket policy.
ObjectAlreadyInActiveTierErrorException: This operation is not allowed against this storage tier
ObjectNotInActiveTierErrorException: The source object of the COPY operation is not in the active tier and is only stored in Amazon Glacier.
OperationAbortedException: A conflicting conditional operation is currently in progress against this resource. Please try again.
S3ExceptionParser: Parses S3 exception responses
PermanentRedirectException: The bucket you are attempting to access must be addressed using the specified endpoint. Please send all future requests to this endpoint.
PreconditionFailedException: At least one of the preconditions you specified did not hold.
RedirectException: Temporary redirect.
RequestIsNotMultiPartContentException: Bucket POST must be of the enclosure-type multipart/form-data.
RequestTimeoutException: Your socket connection to the server was not read from or written to within the timeout period.
RequestTimeTooSkewedException: The difference between the request time and the server's time is too large.
RequestTorrentOfBucketErrorException: Requesting the torrent file of a bucket is not permitted.
S3Exception: Default service exception class
ServiceUnavailableException: Please reduce your request rate.
SignatureDoesNotMatchException: The request signature we calculated does not match the signature you provided. Check your AWS Secret Access Key and signing method. For more information, see REST Authentication and SOAP Authentication for details.
SlowDownException: Please reduce your request rate.
TemporaryRedirectException: You are being redirected to the bucket while DNS updates.
TokenRefreshRequiredException: The provided token must be refreshed.
TooManyBucketsException: You have attempted to create more buckets than allowed.
UnexpectedContentException: This request does not support content.
UnresolvableGrantByEmailAddressException: The e-mail address you provided does not match any account on record.
UserKeyMustBeSpecifiedException: The bucket POST must contain the specified field name. If it is specified, please check the order of the fields.
IncompleteMultipartUploadChecker: Retries CompleteMultipartUpload requests in the case of failure.
ListBucketsIterator: Iterator for the S3 ListBuckets command
ListMultipartUploadsIterator: Iterator for the S3 ListMultipartUploads command
ListObjectsIterator: Iterator for an S3 ListObjects command
ListObjectVersionsIterator: Iterator for an S3 ListObjectVersions command
OpendirIterator: Provides an iterator around an opendir resource. This is useful when you need to provide context to an opendir so you can't use RecursiveDirectoryIterator
Acp: Amazon S3 Access Control Policy (ACP)
AcpBuilder: Builder for creating Access Control Policies
ClearBucket: Class used to clear the contents of a bucket or the results of an iterator
DeleteObjectsBatch: The DeleteObjectsBatch is a BatchDecorator for Guzzle that implements a queue for deleting keys from an Amazon S3 bucket. You can add DeleteObject or an array of [Key => %s, VersionId => %s] and call flush when the objects should be deleted.
DeleteObjectsTransfer: Transfer logic for deleting multiple objects from an Amazon S3 bucket in a single request
Grant: Amazon S3 Grant model
Grantee: Amazon S3 Grantee model
AbstractTransfer: Abstract class for transfer commonalities
ParallelTransfer: Transfers multipart upload parts in parallel
SerialTransfer: Transfers multipart upload parts serially
TransferState: State of a multipart upload
UploadBuilder: Easily create a multipart uploader used to quickly and reliably upload a large file or data stream to Amazon S3 using multipart uploads
UploadId: An object that encapsulates the identification for a Glacier upload part
UploadPart: An object that encapsulates the data for a Glacier upload operation
PostObject: Encapsulates the logic for getting the data for an S3 object POST upload form
ResumableDownload: Allows you to resume the download of a partially downloaded object.
S3Client: Client to interact with Amazon Simple Storage Service
S3Md5Listener: Adds required and optional Content-MD5 headers
S3Signature: Default Amazon S3 signature implementation
S3SignatureV4: Amazon S3 signature version 4 overrides.
SocketTimeoutChecker: Custom S3 exponential backoff checking use to retry 400 responses containing the following reason phrase: "Your socket connection to the server was not read from or written to within the timeout period.".
SseCpkListener: This listener simplifies the SSE-C process by encoding and hashing the key.
StreamWrapper: Amazon S3 stream wrapper to use "s3://<bucket>/<key>" files with PHP streams, supporting "r", "w", "a", "x".
AbstractSync: Class that holds an event dispatcher
AbstractSyncBuilder
ChangedFilesIterator: Iterator used to filter an internal iterator to only yield files that do not exist in the target iterator or files that have changed
DownloadSync: Downloads and Amazon S3 bucket to a local directory
DownloadSyncBuilder
KeyConverter: Converts filenames from one system to another
UploadSync: Uploads a local directory tree to Amazon S3
UploadSyncBuilder
AbstractBatchDecorator: Abstract decorator used when decorating a BatchInterface
Batch: Default batch implementation used to convert queued items into smaller chunks of batches using a {@see BatchDivisorIterface} and transfers each batch using a {@see BatchTransferInterface}.
BatchBuilder: Builder used to create custom batch objects
BatchClosureDivisor: Divides batches using a callable
BatchClosureTransfer: Batch transfer strategy where transfer logic can be defined via a Closure.
BatchCommandTransfer: Efficiently transfers multiple commands in parallel per client This class is to be used with {@see Guzzle\Batch\BatchInterface}
BatchRequestTransfer: Batch transfer strategy used to efficiently transfer a batch of requests.
BatchSizeDivisor: Divides batches into smaller batches under a certain size
BatchTransferException: Exception thrown during a batch transfer
ExceptionBufferingBatch: BatchInterface decorator used to buffer exceptions encountered during a transfer. The exceptions can then later be processed after a batch flush has completed.
FlushingBatch: BatchInterface decorator used to add automatic flushing of the queue when the size of the queue reaches a threshold.
HistoryBatch: BatchInterface decorator used to keep a history of items that were added to the batch. You must clear the history manually to remove items from the history.
NotifyingBatch: BatchInterface decorator used to call a method each time flush is called
AbstractHasDispatcher: Class that holds an event dispatcher
Collection: Key value pair collection object
Event: Default event for Guzzle notifications
BadMethodCallException
ExceptionCollection: Collection of exceptions
InvalidArgumentException
RuntimeException
UnexpectedValueException
Version: Guzzle version information
AbstractEntityBodyDecorator: Abstract decorator used to wrap entity bodies
CachingEntityBody: EntityBody decorator that can cache previously read bytes from a sequentially read tstream
Client: HTTP client
CurlHandle: Immutable wrapper for a cURL handle
CurlMulti: Send {@see RequestInterface} objects in parallel using curl_multi
CurlMultiProxy: Proxies requests and connections to a pool of internal curl_multi handles. Each recursive call will add requests to the next available CurlMulti handle.
CurlVersion: Class used for querying curl_version data
RequestMediator: Mediator between curl handles and request objects
EntityBody: Entity body used with an HTTP request or response
BadResponseException: Http request exception thrown when a bad response is received
ClientErrorResponseException: Exception when a client error is encountered (4xx codes)
CouldNotRewindStreamException
CurlException: cURL request exception
MultiTransferException: Exception encountered during a multi transfer
RequestException: Http request exception
ServerErrorResponseException: Exception when a server error is encountered (5xx codes)
TooManyRedirectsException: Http request exception thrown when a bad response is received
IoEmittingEntityBody: EntityBody decorator that emits events for read and write methods
AbstractMessage: Abstract HTTP request/response message
EntityEnclosingRequest: HTTP request that sends an entity-body in the request message (POST, PUT, PATCH, DELETE)
CacheControl: Provides helpful functionality for Cache-Control headers
HeaderCollection: Provides a case-insensitive collection of headers
HeaderFactory: Default header factory implementation
Link: Provides helpful functionality for link headers
Header: Represents a header and all of the values stored by that header
PostFile: POST file upload
Request: HTTP request class to send requests
RequestFactory: Default HTTP request factory used to create the default {@see Request} and {@see EntityEnclosingRequest} objects.
Response: Guzzle HTTP response object
Mimetypes: Provides mappings of file extensions to mimetypes
CommaAggregator: Aggregates nested query string variables using commas
DuplicateAggregator: Does not aggregate nested query string values and allows duplicates in the resulting array
PhpAggregator: Aggregates nested query string variables using PHP style []
QueryString: Query string object to handle managing query string parameters and aggregating those parameters together as a string.
ReadLimitEntityBody: EntityBody decorator used to return only a subset of an entity body
RedirectPlugin: Plugin to implement HTTP redirects. Can redirect like a web browser or using strict RFC 2616 compliance
StaticClient: Simplified interface to Guzzle that does not require a class to be instantiated
Url: Parses and generates URLs based on URL parts. In favor of performance, URL parts are not validated.
Inflector: Default inflection implementation
MemoizingInflector: Decorator used to add memoization to previously inflected words
PreComputedInflector: Decorator used to add pre-computed inflection mappings to an inflector
AppendIterator: AppendIterator that is not affected by https://bugs.php.net/bug.php?id=49104
ChunkedIterator: Pulls out chunks from an inner iterator and yields the chunks as arrays
FilterIterator: Filters values using a callback
MapIterator: Maps values before yielding
MethodProxyIterator: Proxies missing method calls to the innermost iterator
AbstractLogAdapter: Adapter class that allows Guzzle to log data using various logging implementations
ArrayLogAdapter: Stores all log messages in an array
ClosureLogAdapter: Logs messages using Closures. Closures combined with filtering can trigger application events based on log messages.
MessageFormatter: Message formatter used in various places in the framework
MonologLogAdapter: Adapter class that allows Guzzle to log data using various logging implementations
PsrLogAdapter: PSR-3 log adapter
Zf1LogAdapter: Adapts a Zend Framework 1 logger object
Zf2LogAdapter: Adapts a Zend Framework 2 logger object
CookieParser: Default Guzzle implementation of a Cookie parser
AbstractMessageParser: Implements shared message parsing functionality
MessageParser: Default request and response parser used by Guzzle. Optimized for speed.
PeclHttpMessageParser: Pecl HTTP message parser
ParserRegistry: Registry of parsers used by the application
PeclUriTemplate: Expands URI templates using the uri_template pecl extension (pecl install uri_template-beta)
UriTemplate: Expands URI templates using an array of variables
UrlParser: Parses URLs into parts using PHP's built-in parse_url() function
AsyncPlugin: Sends requests but does not wait for the response
AbstractBackoffStrategy: Abstract backoff strategy that allows for a chain of responsibility
AbstractErrorCodeBackoffStrategy: Strategy used to retry when certain error codes are encountered
BackoffLogger: Logs backoff retries triggered from the BackoffPlugin
BackoffPlugin: Plugin to automatically retry failed HTTP requests using a backoff strategy
CallbackBackoffStrategy: Strategy that will invoke a closure to determine whether or not to retry with a delay
ConstantBackoffStrategy: Will retry the request using the same amount of delay for each retry.
CurlBackoffStrategy: Strategy used to retry when certain cURL error codes are encountered.
ExponentialBackoffStrategy: Implements an exponential backoff retry strategy.
HttpBackoffStrategy: Strategy used to retry HTTP requests based on the response code.
LinearBackoffStrategy: Implements a linear backoff retry strategy.
ReasonPhraseBackoffStrategy: Strategy used to retry HTTP requests when the response's reason phrase matches one of the registered phrases.
TruncatedBackoffStrategy: Strategy that will not retry more than a certain number of times.
Cookie: Set-Cookie object
ArrayCookieJar: Cookie cookieJar that stores cookies an an array
FileCookieJar: Persists non-session cookies using a JSON formatted file
CookiePlugin: Adds, extracts, and persists cookies between HTTP requests
InvalidCookieException
CurlAuthPlugin: Adds specified curl auth to all requests sent from a client. Defaults to CURLAUTH_BASIC if none supplied.
ErrorResponsePlugin: Converts generic Guzzle response exceptions into errorResponse exceptions
ErrorResponseException
HistoryPlugin: Maintains a list of requests and responses sent using a request or client
LogPlugin: Plugin class that will add request and response logging to an HTTP request.
CommandContentMd5Plugin: Listener used to add a ContentMD5 header to the body of a command and adds ContentMD5 validation if the ValidateMD5 option is not set to false on a command
Md5ValidatorPlugin: Ensures that an the MD5 hash of an entity body matches the Content-MD5 header (if set) of an HTTP response. An exception is thrown if the calculated MD5 does not match the expected MD5.
MockPlugin: Queues mock responses or exceptions and delivers mock responses or exceptions in a fifo order.
OauthPlugin: OAuth signing plugin
AbstractConfigLoader: Abstract config loader
ServiceBuilder: Class that holds an event dispatcher
ServiceBuilderLoader: Service builder config loader
CachingConfigLoader: Decorator that adds caching to a service description loader
Client: Client object for executing commands on a web service.
AbstractCommand: Command object to handle preparing and processing client requests and responses of the requests
ClosureCommand: A ClosureCommand is a command that allows dynamic commands to be created at runtime using a closure to prepare the request. A closure key and \Closure value must be passed to the command in the constructor. The closure must accept the command object as an argument.
CreateResponseClassEvent: Event class emitted with the operation.parse_class event
DefaultRequestSerializer: Default request serializer that transforms command options and operation parameters into a request
DefaultResponseParser: Default HTTP response parser used to marshal JSON responses into arrays and XML responses into SimpleXMLElement
AliasFactory: Command factory used when you need to provide aliases to commands
CompositeFactory: Composite factory used by a client object to create command objects utilizing multiple factories
ConcreteClassFactory: Command factory used to create commands referencing concrete command classes
MapFactory: Command factory used when explicitly mapping strings to command classes
ServiceDescriptionFactory: Command factory used to create commands based on service descriptions
AbstractRequestVisitor
BodyVisitor: Visitor used to apply a body to a request
HeaderVisitor: Visitor used to apply a parameter to a header value
JsonVisitor: Visitor used to apply a parameter to an array that will be serialized as a top level key-value pair in a JSON body
PostFieldVisitor: Visitor used to apply a parameter to a POST field
PostFileVisitor: Visitor used to apply a parameter to a POST file
QueryVisitor: Visitor used to apply a parameter to a request's query string
ResponseBodyVisitor: Visitor used to change the location in which a response body is saved
XmlVisitor: Location visitor used to serialize XML bodies
AbstractResponseVisitor: {@inheritdoc}
BodyVisitor: Visitor used to add the body of a response to a particular key
HeaderVisitor: Location visitor used to add a particular header of a response to a key in the result
JsonVisitor: Location visitor used to marshal JSON response data into a formatted array.
ReasonPhraseVisitor: Location visitor used to add the reason phrase of a response to a key in the result
StatusCodeVisitor: Location visitor used to add the status code of a response to a key in the result
XmlVisitor: Location visitor used to marshal XML response data into a formatted array
VisitorFlyweight: Flyweight factory used to instantiate request and response visitors
OperationCommand: A command that creates requests based on {@see Guzzle\Service\Description\OperationInterface} objects, and if the matching operation uses a service description model in the responseClass attribute, then this command will marshal the response into an associative array based on the JSON schema of the model.
OperationResponseParser: Response parser that attempts to marshal responses into an associative array based on models in a service description
Operation: Data object holding the information of an API command
Parameter: API parameter object used with service descriptions
SchemaFormatter: JSON Schema formatter class
SchemaValidator: Default parameter validator
ServiceDescription: A ServiceDescription stores service information based on a service document
ServiceDescriptionLoader: Loader for service descriptions
CommandException
CommandTransferException: Exception thrown when transferring commands in parallel
DescriptionBuilderException
InconsistentClientTransferException: Command transfer exception when commands do not all use the same client
ResponseClassException
ServiceBuilderException
ServiceNotFoundException
ValidationException
AbstractResourceIteratorFactory: Abstract resource iterator factory implementation
CompositeResourceIteratorFactory: Factory that utilizes multiple factories for creating iterators
MapResourceIteratorFactory: Resource iterator factory used when explicitly mapping strings to iterator classes
Model: Default model created when commands create service description model responses
ResourceIterator: Class that holds an event dispatcher
ResourceIteratorApplyBatched: Apply a callback to the contents of a {@see ResourceIteratorInterface}
ResourceIteratorClassFactory: Factory for creating {@see ResourceIteratorInterface} objects using a convention of storing iterator classes under a root namespace using the name of a {@see CommandInterface} object as a convention for determining the name of an iterator class. The command name is converted to CamelCase and Iterator is appended (e.g. abc_foo => AbcFoo).
PhpStreamRequestFactory: Factory used to create fopen streams using PHP's http and https stream wrappers
Stream: PHP stream implementation
AbstractLogger: This is a simple Logger implementation that other Loggers can inherit from.
InvalidArgumentException
LogLevel: Describes log levels
NullLogger: This Logger can be used to avoid conditional log calls
LoggerInterfaceTest: Provides a base test class for ensuring compliance with the LoggerInterface
DummyTest
ContainerAwareEventDispatcher: Lazily loads listeners and subscribers from the dependency injection container.
TraceableEventDispatcher: Collects some data about event listeners.
WrappedListener
RegisterListenersPass: Compiler pass to register tagged services for an event dispatcher.
Event: Event is the base class for classes containing event data.
EventDispatcher: The EventDispatcherInterface is the central point of Symfony's event listener system.
GenericEvent: Event encapsulation class.
ImmutableEventDispatcher: A read-only proxy for an event dispatcher.
AbstractEventDispatcherTest
CallableClass
TestEventListener
TestWithDispatcher
TestEventSubscriber
TestEventSubscriberWithPriorities
TestEventSubscriberWithMultipleListeners
ContainerAwareEventDispatcherTest
Service
SubscriberService
TraceableEventDispatcherTest
EventSubscriber
RegisterListenersPassTest
SubscriberService
EventDispatcherTest
EventTest: Test class for Event.
GenericEventTest: Test class for Event.
ImmutableEventDispatcherTest
ComposerAutoloaderInit41ec22823faeb187c2fc8ae78a2d5464
ComposerStaticInit41ec22823faeb187c2fc8ae78a2d5464
ClassLoader: ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
InstalledVersions: This class is copied in every Composer installed project and available to all
BeforeValidException
CachedKeySet
ExpiredException
Key
SignatureInvalidException
Revoke: Wrapper around Google Access Tokens which provides convenience functions
Verify: Wrapper around Google Access Tokens which provides convenience functions
Google_Task_Composer: This class needs to be defined explicitly as scripts must be recognized by the autoloader.
Google_AccessToken_Revoke: Wrapper around Google Access Tokens which provides convenience functions
Google_AccessToken_Verify: Wrapper around Google Access Tokens which provides convenience functions
Google_AuthHandler_AuthHandlerFactory
Google_AuthHandler_Guzzle5AuthHandler
Google_AuthHandler_Guzzle6AuthHandler: This supports Guzzle 6
Google_AuthHandler_Guzzle7AuthHandler: This supports Guzzle 7
Google_Client: The Google API Client https://github.com/google/google-api-php-client
Google_Collection: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
Google_Exception
Google_Http_Batch: Class to handle batched requests to the Google API service.
Google_Http_MediaFileUpload: Manage large file uploads, which may be media but can be any type of sizable data.
Google_Http_REST: This class implements the RESTful transport of apiServiceRequest()'s
Google_Model: This class defines attributes, valid values, and usage which is generated from a given json schema.
Google_Service
Google_Service_Exception
Google_Service_Resource: Implements the actual methods/resources of the discovered Google API using magic function calling overloading (__call()), which on call will see if the method name (plus.activities.list) is available in this service, and if so construct an apiHttpRequest representing it.
Google_Task_Exception
Google_Task_Runner: A task runner with exponential backoff support.
Google_Utils_UriTemplate: Implementation of levels 1-3 of the URI Template spec.
AuthHandlerFactory
Guzzle5AuthHandler
Guzzle6AuthHandler: This supports Guzzle 6
Guzzle7AuthHandler: This supports Guzzle 7
Client: The Google API Client https://github.com/google/google-api-php-client
Collection: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
Exception
Batch: Class to handle batched requests to the Google API service.
MediaFileUpload: Manage large file uploads, which may be media but can be any type of sizable data.
REST: This class implements the RESTful transport of apiServiceRequest()'s
Model: This class defines attributes, valid values, and usage which is generated from a given json schema.
Exception
Resource: Implements the actual methods/resources of the discovered Google API using magic function calling overloading (__call()), which on call will see if the method name (plus.activities.list) is available in this service, and if so construct an apiHttpRequest representing it.
Service
Composer
Exception
Runner: A task runner with exponential backoff support.
UriTemplate: Implementation of levels 1-3 of the URI Template spec.
About: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
AboutDriveThemes: This class defines attributes, valid values, and usage which is generated from a given json schema.
AboutStorageQuota: This class defines attributes, valid values, and usage which is generated from a given json schema.
AboutTeamDriveThemes: This class defines attributes, valid values, and usage which is generated from a given json schema.
Change: This class defines attributes, valid values, and usage which is generated from a given json schema.
ChangeList: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
Channel: This class defines attributes, valid values, and usage which is generated from a given json schema.
Comment: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
CommentList: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
CommentQuotedFileContent: This class defines attributes, valid values, and usage which is generated from a given json schema.
ContentRestriction: This class defines attributes, valid values, and usage which is generated from a given json schema.
Drive: This class defines attributes, valid values, and usage which is generated from a given json schema.
DriveBackgroundImageFile: This class defines attributes, valid values, and usage which is generated from a given json schema.
DriveCapabilities: This class defines attributes, valid values, and usage which is generated from a given json schema.
DriveFile: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
DriveFileCapabilities: This class defines attributes, valid values, and usage which is generated from a given json schema.
DriveFileContentHints: This class defines attributes, valid values, and usage which is generated from a given json schema.
DriveFileContentHintsThumbnail: This class defines attributes, valid values, and usage which is generated from a given json schema.
DriveFileImageMediaMetadata: This class defines attributes, valid values, and usage which is generated from a given json schema.
DriveFileImageMediaMetadataLocation: This class defines attributes, valid values, and usage which is generated from a given json schema.
DriveFileLinkShareMetadata: This class defines attributes, valid values, and usage which is generated from a given json schema.
DriveFileShortcutDetails: This class defines attributes, valid values, and usage which is generated from a given json schema.
DriveFileVideoMediaMetadata: This class defines attributes, valid values, and usage which is generated from a given json schema.
DriveList: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
DriveRestrictions: This class defines attributes, valid values, and usage which is generated from a given json schema.
FileList: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
GeneratedIds: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
Permission: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
PermissionList: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
PermissionPermissionDetails: This class defines attributes, valid values, and usage which is generated from a given json schema.
PermissionTeamDrivePermissionDetails: This class defines attributes, valid values, and usage which is generated from a given json schema.
Reply: This class defines attributes, valid values, and usage which is generated from a given json schema.
ReplyList: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
About: The "about" collection of methods.
Changes: The "changes" collection of methods.
Channels: The "channels" collection of methods.
Comments: The "comments" collection of methods.
Drives: The "drives" collection of methods.
Files: The "files" collection of methods.
Permissions: The "permissions" collection of methods.
Replies: The "replies" collection of methods.
Revisions: The "revisions" collection of methods.
Teamdrives: The "teamdrives" collection of methods.
Revision: This class defines attributes, valid values, and usage which is generated from a given json schema.
RevisionList: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
StartPageToken: This class defines attributes, valid values, and usage which is generated from a given json schema.
TeamDrive: This class defines attributes, valid values, and usage which is generated from a given json schema.
TeamDriveBackgroundImageFile: This class defines attributes, valid values, and usage which is generated from a given json schema.
TeamDriveCapabilities: This class defines attributes, valid values, and usage which is generated from a given json schema.
TeamDriveList: Extension to the regular Google\Model that automatically exposes the items array for iteration, so you can just iterate over the object rather than a reference inside.
TeamDriveRestrictions: This class defines attributes, valid values, and usage which is generated from a given json schema.
User: This class defines attributes, valid values, and usage which is generated from a given json schema.
Drive: Service definition for Drive (v3).
Userinfo: The "userinfo" collection of methods.
UserinfoV2: The "v2" collection of methods.
UserinfoV2Me: The "me" collection of methods.
Tokeninfo: This class defines attributes, valid values, and usage which is generated from a given json schema.
Userinfo: This class defines attributes, valid values, and usage which is generated from a given json schema.
Oauth2: Service definition for Oauth2 (v2).
AccessToken: Wrapper around Google Access Tokens which provides convenience functions.
ApplicationDefaultCredentials: ApplicationDefaultCredentials obtains the default credentials for authorizing a request to a Google service.
InvalidArgumentException
Item: A cache item.
MemoryCacheItemPool: Simple in-memory cache implementation.
SysVCacheItemPool: SystemV shared memory based CacheItemPool implementation.
AppIdentityCredentials: AppIdentityCredentials supports authorization on Google App Engine.
GCECredentials: GCECredentials supports authorization on Google Compute Engine.
IAMCredentials: Authenticates requests using IAM credentials.
InsecureCredentials: Provides a set of credentials that will always return an empty access token.
ServiceAccountCredentials: ServiceAccountCredentials supports authorization using a Google service account.
ServiceAccountJwtAccessCredentials: Authenticates requests using Google's Service Account credentials via JWT Access.
UserRefreshCredentials: Authenticates requests using User Refresh credentials.
CredentialsLoader: CredentialsLoader contains the behaviour used to locate and find default credentials files on the file system.
FetchAuthTokenCache: A class to implement caching for any object implementing FetchAuthTokenInterface
GCECache: A class to implement caching for calls to GCECredentials::onGce. This class is used automatically when you pass a `Psr\Cache\CacheItemPoolInterface` cache object to `ApplicationDefaultCredentials::getCredentials`.
Guzzle5HttpHandler
Guzzle6HttpHandler
Guzzle7HttpHandler
HttpClientCache: Stores an HTTP Client in order to prevent multiple instantiations.
HttpHandlerFactory
Iam: Tools for using the IAM API.
AuthTokenMiddleware: AuthTokenMiddleware is a Guzzle Middleware that adds an Authorization header provided by an object implementing FetchAuthTokenInterface.
ScopedAccessTokenMiddleware: ScopedAccessTokenMiddleware is a Guzzle Middleware that adds an Authorization header provided by a closure.
SimpleMiddleware: SimpleMiddleware is a Guzzle Middleware that implements Google's Simple API access.
OAuth2: OAuth2 supports authentication by OAuth2 2-legged flows.
AuthTokenSubscriber: AuthTokenSubscriber is a Guzzle Subscriber that adds an Authorization header provided by an object implementing FetchAuthTokenInterface.
ScopedAccessTokenSubscriber: ScopedAccessTokenSubscriber is a Guzzle Subscriber that adds an Authorization header provided by a closure.
SimpleSubscriber: SimpleSubscriber is a Guzzle Subscriber that implements Google's Simple API access.
Client
CookieJar: Cookie jar that stores cookies as an array
FileCookieJar: Persists non-session cookies using a JSON formatted file
SessionCookieJar: Persists cookies in the client session
SetCookie: Set-Cookie object
BadResponseException: Exception when an HTTP error occurs (4xx or 5xx error)
ClientException: Exception when a client error is encountered (4xx codes)
ConnectException: Exception thrown when a connection cannot be established.
InvalidArgumentException
RequestException: HTTP Request exception
SeekException: Exception thrown when a seek fails on a stream.
ServerException: Exception when a server error is encountered (5xx codes)
TooManyRedirectsException: HTTP Request exception
TransferException
CurlFactory: Creates curl resources from a request
CurlHandler: HTTP handler that uses cURL easy handles as a transport layer.
CurlMultiHandler: Returns an asynchronous response using curl_multi_* functions.
MockHandler: Handler that returns responses or throw exceptions from a queue.
Proxy: Provides basic proxies for handlers.
StreamHandler: HTTP handler that uses PHP's HTTP stream wrapper.
HandlerStack: Creates a composed Guzzle handler function by stacking middlewares on top of an HTTP handler function.
MessageFormatter: Formats log messages using variable substitutions for requests, responses, and other transactional data.
Middleware: Functions used to create and wrap handlers with handler middleware.
Pool: Sends an iterator of requests concurrently using a capped pool size.
PrepareBodyMiddleware: Prepares requests that contain a body, adding the Content-Length, Content-Type, and Expect headers.
RedirectMiddleware: Request redirect middleware.
RequestOptions: This class contains a list of built-in Guzzle request options.
RetryMiddleware: Middleware that retries requests based on the boolean result of invoking the provided "decider" function.
TransferStats: Represents data at the point after it was transferred either successfully or after a network error.
UriTemplate: Expands URI templates. Userland implementation of PECL uri_template.
Utils
AggregateException: Exception thrown when too many errors occur in the some() or any() methods.
CancellationException: Exception that is set as the reason for a promise that has been cancelled.
Coroutine: Creates a promise that is resolved using a generator that yields values or promises (somewhat similar to C#'s async keyword).
Create
Each
EachPromise: Represents a promise that iterates over many promises and invokes side-effect functions in the process.
FulfilledPromise: A promise that has been fulfilled.
Is
Promise: Promises/A+ implementation that avoids recursion when possible.
RejectedPromise: A promise that has been rejected.
RejectionException: A special exception that is thrown when waiting on a rejected promise.
TaskQueue: A task queue that executes tasks in a FIFO order.
Utils
AppendStream: Reads from multiple streams, one after the other.
BufferStream: Provides a buffer stream that can be written to to fill a buffer, and read from to remove bytes from the buffer.
CachingStream: Stream decorator that can cache previously read bytes from a sequentially read stream.
DroppingStream: Stream decorator that begins dropping data once the size of the underlying stream becomes too full.
MalformedUriException: Exception thrown if a URI cannot be parsed because it's malformed.
FnStream: Compose stream implementations based on a hash of functions.
Header
HttpFactory: Implements all of the PSR-17 interfaces.
InflateStream: Uses PHP's zlib.inflate filter to inflate zlib (HTTP deflate, RFC1950) or gzipped (RFC1952) content.
LazyOpenStream: Lazily reads or writes to a file that is opened only after an IO operation take place on the stream.
LimitStream: Decorator used to return only a subset of a stream.
Message
MimeType
MultipartStream: Stream that when read returns bytes for a streaming multipart or multipart/form-data stream.
NoSeekStream: Stream decorator that prevents a stream from being seeked.
PumpStream: Provides a read only stream that pumps data from a PHP callable.
Query
Request: PSR-7 request implementation.
Response: PSR-7 response implementation.
ServerRequest: Server-side HTTP request
Stream: PHP stream implementation.
StreamWrapper: Converts Guzzle streams into PHP stream resources.
UploadedFile
Uri: PSR-7 URI implementation.
UriComparator: Provides methods to determine if a modified URL should be considered cross-origin.
UriNormalizer: Provides methods to normalize and compare URIs.
UriResolver: Resolves a URI reference in the context of a base URI and the opposite way.
Utils
ErrorHandler: Monolog error handler
ChromePHPFormatter: Formats a log message according to the ChromePHP array format
ElasticaFormatter: Format a log message into an Elastica Document
FlowdockFormatter: formats the record to be used in the FlowdockHandler
FluentdFormatter: Class FluentdFormatter
GelfMessageFormatter: Serializes a log message to GELF
HtmlFormatter: Formats incoming records into an HTML table
JsonFormatter: Encodes whatever record data is passed to it as json
LineFormatter: Formats incoming records into a one-line string
LogglyFormatter: Encodes message information into JSON in a format compatible with Loggly.
LogstashFormatter: Serializes a log message to Logstash Event Format
MongoDBFormatter: Formats a record for use with the MongoDBHandler.
NormalizerFormatter: Normalizes incoming records to remove objects/resources so it's easier to dump to various targets
ScalarFormatter: Formats data into an associative array of scalar values.
WildfireFormatter: Serializes a log message according to Wildfire's header requirements
AbstractHandler: Base Handler class providing the Handler structure
AbstractProcessingHandler: Base Handler class providing the Handler structure
AbstractSyslogHandler: Common syslog functionality
AmqpHandler: Base Handler class providing the Handler structure
BrowserConsoleHandler: Handler sending logs to browser's javascript console with no browser extension required
BufferHandler: Buffers all records until closing the handler and then pass them as batch.
ChromePHPHandler: Handler sending logs to the ChromePHP extension (http://www.chromephp.com/)
CouchDBHandler: CouchDB handler
CubeHandler: Logs to Cube.
Util
DeduplicationHandler: Simple handler wrapper that deduplicates log records across multiple requests
DoctrineCouchDBHandler: CouchDB handler for Doctrine CouchDB ODM
DynamoDbHandler: Amazon DynamoDB handler (http://aws.amazon.com/dynamodb/)
ElasticSearchHandler: Elastic Search handler
ErrorLogHandler: Stores to PHP error_log() handler.
FilterHandler: Simple handler wrapper that filters records based on a list of levels
ChannelLevelActivationStrategy: Channel and Error level based monolog activation strategy. Allows to trigger activation based on level per channel. e.g. trigger activation on level 'ERROR' by default, except for records of the 'sql' channel; those should trigger activation on level 'WARN'.
ErrorLevelActivationStrategy: Error level based activation strategy.
FingersCrossedHandler: Buffers all records until a certain level is reached
FirePHPHandler: Simple FirePHP Handler (http://www.firephp.org/), which uses the Wildfire protocol.
FleepHookHandler: Sends logs to Fleep.io using Webhook integrations
FlowdockHandler: Sends notifications through the Flowdock push API
GelfHandler: Handler to send messages to a Graylog2 (http://www.graylog2.org) server
GroupHandler: Forwards records to multiple handlers
HandlerWrapper: This simple wrapper class can be used to extend handlers functionality.
HipChatHandler: Sends notifications through the hipchat api to a hipchat room
IFTTTHandler: IFTTTHandler uses cURL to trigger IFTTT Maker actions
InsightOpsHandler: Inspired on LogEntriesHandler.
LogEntriesHandler: Stores to any socket - uses fsockopen() or pfsockopen().
LogglyHandler: Sends errors to Loggly.
MailHandler: Base class for all mail handlers
MandrillHandler: MandrillHandler uses cURL to send the emails to the Mandrill API
MissingExtensionException: Exception can be thrown if an extension for an handler is missing
MongoDBHandler: Logs to a MongoDB database.
NativeMailerHandler: NativeMailerHandler uses the mail() function to send the emails
NewRelicHandler: Class to record a log on a NewRelic application.
NullHandler: Blackhole
PHPConsoleHandler: Monolog handler for Google Chrome extension "PHP Console"
PsrHandler: Proxies log messages to an existing PSR-3 compliant logger.
PushoverHandler: Sends notifications through the pushover api to mobile phones
RavenHandler: Handler to send messages to a Sentry (https://github.com/getsentry/sentry) server using sentry-php (https://github.com/getsentry/sentry-php)
RedisHandler: Logs to a Redis key using rpush
RollbarHandler: Sends errors to Rollbar
RotatingFileHandler: Stores logs to files that are rotated every day and a limited number of files are kept.
SamplingHandler: Sampling handler
SlackRecord: Slack record utility helping to log to Slack webhooks or API.
SlackbotHandler: Sends notifications through Slack's Slackbot
SlackHandler: Sends notifications through Slack API
SlackWebhookHandler: Sends notifications through Slack Webhooks
SocketHandler: Stores to any socket - uses fsockopen() or pfsockopen().
StreamHandler: Stores to any stream resource
SwiftMailerHandler: SwiftMailerHandler uses Swift_Mailer to send the emails
SyslogHandler: Logs to syslog service.
UdpSocket
SyslogUdpHandler: A Handler for logging to a remote syslogd server.
TestHandler: Used for testing purposes.
WhatFailureGroupHandler: Forwards records to multiple handlers suppressing failures of each handler and continuing through to give every handler a chance to succeed.
ZendMonitorHandler: Handler sending logs to Zend Monitor
Logger: Monolog log channel
GitProcessor: Injects Git branch and Git commit SHA in all records
IntrospectionProcessor: Injects line/file:class/function where the log message came from
MemoryPeakUsageProcessor: Injects memory_get_peak_usage in all records
MemoryProcessor: Some methods that are common for all memory processors
MemoryUsageProcessor: Injects memory_get_usage in all records
MercurialProcessor: Injects Hg branch and Hg revision number in all records
ProcessIdProcessor: Adds value of getmypid into records
PsrLogMessageProcessor: Processes a record's message according to PSR-3 rules
TagProcessor: Adds a tags array into record
UidProcessor: Adds a unique identifier into records
WebProcessor: Injects url/method and remote IP of the current web request in all records
Registry: Monolog log registry
SignalHandler: Monolog POSIX signal handler
Utils
Base32HexTest
Base32Test
Base64DotSlashOrderedTest
Base64DotSlashTest
Base64Test
Base64UrlSafeTest
EncodingTest
HexTest
RFC4648Test: Class RFC4648Test
Error
TypeError
AbstractLogger: This is a simple Logger implementation that other Loggers can inherit from.
InvalidArgumentException
LogLevel: Describes log levels.
NullLogger: This Logger can be used to avoid conditional log calls.
LoggerInterfaceTest: Provides a base test class for ensuring compliance with the LoggerInterface.
TestLogger: Used for testing purposes.
Normalizer
ArithmeticError
AssertionError
DivisionByZeroError
Error
ParseError
TypeError
xmlrpc_client
xmlrpcresp
xmlrpcmsg
xmlrpcval
xmlrpc_server
sef_easyblog

Traits

LoggerAwareTrait: Basic Implementation of LoggerAwareInterface.
LoggerTrait: This is a simple Logger trait that classes unable to extend AbstractLogger (because they extend another class, etc) can include.
CacheTrait
ServiceAccountSignerTrait: Sign a string using a Service Account private key.
MessageTrait: Trait implementing functionality common to requests and responses.
StreamDecoratorTrait: Stream decorator trait
FormattableHandlerTrait: Helper trait for implementing FormattableInterface
ProcessableHandlerTrait: Helper trait for implementing ProcessableInterface
LoggerAwareTrait: Basic Implementation of LoggerAwareInterface.
LoggerTrait: This is a simple Logger trait that classes unable to extend AbstractLogger (because they extend another class, etc) can include.

Constants

CRYPT_RSA_MODE = constant($this->getOpenSslConstant())
CRYPT_RSA_MODE = RSA::MODE_OPENSSL
false = \true
IDNA_ALLOW_UNASSIGNED = 1
IDNA_CHECK_BIDI = 4
IDNA_CHECK_CONTEXTJ = 8
IDNA_DEFAULT = 0
IDNA_ERROR_BIDI = 2048
IDNA_ERROR_CONTEXTJ = 4096
IDNA_ERROR_DISALLOWED = 128
IDNA_ERROR_DOMAIN_NAME_TOO_LONG = 4
IDNA_ERROR_EMPTY_LABEL = 1
IDNA_ERROR_HYPHEN_3_4 = 32
IDNA_ERROR_INVALID_ACE_LABEL = 1024
IDNA_ERROR_LABEL_HAS_DOT = 512
IDNA_ERROR_LABEL_TOO_LONG = 2
IDNA_ERROR_LEADING_COMBINING_MARK = 64
IDNA_ERROR_LEADING_HYPHEN = 8
IDNA_ERROR_PUNYCODE = 256
IDNA_ERROR_TRAILING_HYPHEN = 16
IDNA_NONTRANSITIONAL_TO_ASCII = 16
IDNA_NONTRANSITIONAL_TO_UNICODE = 32
IDNA_USE_STD3_RULES = 2
INTL_IDNA_VARIANT_2003 = 0
INTL_IDNA_VARIANT_UTS46 = 1
MATH_BIGINTEGER_OPENSSL_ENABLED = true
MATH_BIGINTEGER_OPENSSL_ENABLED = true
null = \true
PHP_FLOAT_DIG = 15
PHP_FLOAT_EPSILON = 2.2204460492503E-16
PHP_FLOAT_MAX = 1.7976931348623157E+308
PHP_FLOAT_MIN = 2.2250738585072E-308
PHP_INT_MIN = ~\PHP_INT_MAX
PHP_OS_FAMILY = \Symfony\Polyfill\Php72\Php72::php_os_family()
PHP_VERSION_ID = $RandomCompatversion[0] * 10000 + $RandomCompatversion[1] * 100 + $RandomCompatversion[2]
PHP_XMLRPC_COMPAT_DIR = \dirname(__FILE__) . '/compat/'
RANDOM_COMPAT_READ_BUFFER = 8
RANDOM_COMPAT_READ_BUFFER = 8
true = \false
U_IDNA_ACE_PREFIX_ERROR = 66564
U_IDNA_CHECK_BIDI_ERROR = 66562
U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR = 66568
U_IDNA_ERROR_LIMIT = 66569
U_IDNA_ERROR_START = 66560
U_IDNA_LABEL_TOO_LONG_ERROR = 66566
U_IDNA_PROHIBITED_ERROR = 66560
U_IDNA_STD3_ASCII_RULES_ERROR = 66563
U_IDNA_UNASSIGNED_ERROR = 66561
U_IDNA_VERIFICATION_ERROR = 66565
U_IDNA_ZERO_LENGTH_LABEL_ERROR = 66567
U_STRINGPREP_CHECK_BIDI_ERROR = 66562
U_STRINGPREP_PROHIBITED_ERROR = 66560
U_STRINGPREP_UNASSIGNED_ERROR = 66561
XMLRPC_EPI_ENABLED = '0'

Functions

htmLawed() : mixed
hl_attrval() : mixed
hl_bal() : mixed
hl_cmtcd() : mixed
hl_ent() : mixed
hl_prot() : mixed
hl_regex() : mixed
hl_spec() : mixed
hl_tag() : mixed
hl_tag2() : mixed
hl_tidy() : mixed
hl_version() : mixed
kses() : mixed
kses_hook() : mixed
composerRequire41ec22823faeb187c2fc8ae78a2d5464() : mixed
includeFile() : mixed: Scope isolated include.
oauth2client_php_autoload() : mixed
uri_template() : string: Expands a URI template
describe_type() : string: Debug function used to describe the provided value type and class.
headers_from_lines() : array<string|int, mixed>: Parses an array of header lines into an associative array of headers.
debug_resource() : resource: Returns a debug stream based on the provided variable.
choose_handler() : callable: Chooses and creates a default handler to use based on the environment.
default_user_agent() : string: Get the default User-Agent string to use with Guzzle
default_ca_bundle() : string: Returns the default cacert bundle for the current system.
normalize_header_keys() : array<string|int, mixed>: Creates an associative array of lowercase header names to the actual header casing.
is_host_in_noproxy() : bool: Returns true if the provided host matches any of the no proxy areas.
json_decode() : mixed: Wrapper for json_decode that throws when an error occurs.
json_encode() : string: Wrapper for JSON encoding that throws when an error occurs.
queue() : TaskQueueInterface: Get the global task queue used for promise resolution.
task() : PromiseInterface: Adds a function to run in the task queue when it is next `run()` and returns a promise that is fulfilled or rejected with the result.
promise_for() : PromiseInterface: Creates a promise for a value if the value is not a promise.
rejection_for() : PromiseInterface: Creates a rejected promise for a reason if the reason is not a promise. If the provided reason is a promise, then it is returned as-is.
exception_for() : Exception|Throwable: Create an exception for a rejected promise value.
iter_for() : Iterator: Returns an iterator for the given value.
inspect() : array<string|int, mixed>: Synchronously waits on a promise to resolve and returns an inspection state array.
inspect_all() : array<string|int, mixed>: Waits on all of the provided promises, but does not unwrap rejected promises as thrown exception.
unwrap() : array<string|int, mixed>: Waits on all of the provided promises and returns the fulfilled values.
all() : PromiseInterface: Given an array of promises, return a promise that is fulfilled when all the items in the array are fulfilled.
some() : PromiseInterface: Initiate a competitive race between multiple promises or values (values will become immediately fulfilled promises).
any() : PromiseInterface: Like some(), with 1 as count. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.
settle() : PromiseInterface: Returns a promise that is fulfilled when all of the provided promises have been fulfilled or rejected.
each() : PromiseInterface: Given an iterator that yields promises or values, returns a promise that is fulfilled with a null value when the iterator has been consumed or the aggregate promise has been fulfilled or rejected.
each_limit() : PromiseInterface: Like each, but only allows a certain number of outstanding promises at any given time.
each_limit_all() : PromiseInterface: Like each_limit, but ensures that no promise in the given $iterable argument is rejected. If any promise is rejected, then the aggregate promise is rejected with the encountered rejection.
is_fulfilled() : bool: Returns true if a promise is fulfilled.
is_rejected() : bool: Returns true if a promise is rejected.
is_settled() : bool: Returns true if a promise is fulfilled or rejected.
coroutine() : PromiseInterface: Create a new coroutine.
str() : string: Returns the string representation of an HTTP message.
uri_for() : UriInterface: Returns a UriInterface for the given value.
stream_for() : StreamInterface: Create a new stream based on the input type.
parse_header() : array<string|int, mixed>: Parse an array of header values containing ";" separated data into an array of associative arrays representing the header key value pair data of the header. When a parameter does not contain a value, but just contains a key, this function will inject a key with a '' string value.
normalize_header() : array<string|int, mixed>: Converts an array of header values that may contain comma separated headers into an array of headers with no comma separated values.
modify_request() : RequestInterface: Clone and modify a request with the given changes.
rewind_body() : mixed: Attempts to rewind a message body and throws an exception on failure.
try_fopen() : resource: Safely opens a PHP stream resource using a filename.
copy_to_string() : string: Copy the contents of a stream into a string until the given number of bytes have been read.
copy_to_stream() : mixed: Copy the contents of a stream into another stream until the given number of bytes have been read.
hash() : string: Calculate a hash of a stream.
readline() : string: Read a line from the stream up to the maximum allowed buffer length.
parse_request() : Request: Parses a request message string into a request object.
parse_response() : Response: Parses a response message string into a response object.
parse_query() : array<string|int, mixed>: Parse a query string into an associative array.
build_query() : string: Build a query string from an array of key value pairs.
mimetype_from_filename() : string|null: Determines the mimetype of a file by looking at its extension.
mimetype_from_extension() : string|null: Maps a file extensions to a mimetype.
get_message_body_summary() : string|null: Get a short summary of the message body.
RandomCompat_strlen() : int: strlen() implementation that isn't brittle to mbstring.func_overload
RandomCompat_substr() : string: substr() implementation that isn't brittle to mbstring.func_overload
RandomCompat_intval() : float|int: Cast to an integer if we can, safely.
random_bytes() : string: We don't have any more options, so let's throw an exception right now and hope the developer won't let it fail silently.
random_bytes() : string: Windows with PHP < 5.3.0 will not have the function openssl_random_pseudo_bytes() available, so let's use CAPICOM to work around this deficiency.
random_bytes() : string: Unless open_basedir is enabled, use /dev/urandom for random numbers in accordance with best practices
random_bytes() : string: If the libsodium PHP extension is loaded, we'll use it above any other solution.
random_bytes() : string: If the libsodium PHP extension is loaded, we'll use it above any other solution.
random_bytes() : string: Powered by ext/mcrypt (and thankfully NOT libmcrypt)
random_int() : int: Fetch a random integer between $min and $max inclusive
getallheaders() : mixed: Get all HTTP header key/values as an associative array for the current request.
idn_to_ascii() : mixed
idn_to_utf8() : mixed
normalizer_is_normalized() : mixed
normalizer_normalize() : mixed
intdiv() : mixed
preg_replace_callback_array() : mixed
error_clear_last() : mixed
sapi_windows_vt100_support() : mixed
stream_isatty() : mixed
utf8_encode() : mixed
utf8_decode() : mixed
spl_object_id() : mixed
mb_ord() : mixed
mb_chr() : mixed
mb_scrub() : mixed
xmlrpc_encode_entitites() : mixed: Convert a string to the correct XML representation in a target charset To help correct communication of non-ascii chars inside strings, regardless of the charset used when sending requests, parsing them, sending responses and parsing responses, an option is to convert all non-ascii chars present in the message into their equivalent 'charset entity'. Charset entities enumerated this way are independent of the charset encoding used to transmit them, and all XML parsers are bound to understand them.
xmlrpc_se() : mixed
xmlrpc_se_any() : mixed
xmlrpc_ee() : mixed
xmlrpc_ee_fast() : mixed
xmlrpc_cd() : mixed
xmlrpc_dh() : mixed
iso8601_encode() : string: Given a timestamp, return the corresponding ISO8601 encoded string.
iso8601_decode() : int: Given an ISO8601 date string, return a timet in the localtime, or UTC
php_xmlrpc_decode() : mixed: Takes an xmlrpc value in PHP xmlrpcval object format and translates it into native PHP types.
php_xmlrpc_encode() : xmlrpcval: Takes native php types and encodes them into xmlrpc PHP object format.
php_xmlrpc_decode_xml() : mixed: Convert the xml representation of a method response, method request or single xmlrpc value into the appropriate object (a.k.a. deserialize)
decode_chunked() : string: decode a string that is encoded w/ "chunked" transfer encoding as defined in rfc2068 par. 19.4.6 code shamelessly stolen from nusoap library by Dietrich Ayala
guess_encoding() : mixed: xml charset encoding guessing helper function.
is_valid_charset() : mixed: Checks if a given charset encoding is present in a list of encodings or if it is a valid subset of any encoding in the list
_xmlrpcs_getCapabilities() : mixed
_xmlrpcs_listMethods() : mixed
_xmlrpcs_methodSignature() : mixed
_xmlrpcs_methodHelp() : mixed
_xmlrpcs_multicall_error() : mixed
_xmlrpcs_multicall_do_call() : mixed
_xmlrpcs_multicall_do_call_phpvals() : mixed
_xmlrpcs_multicall() : mixed
_xmlrpcs_errorHandler() : mixed: Error handler used to track errors that occur during server-side execution of PHP code.
xmlrpc_debugmsg() : mixed: Add a string to the debug info that can be later seralized by the server as part of the response message.

CRYPT_RSA_MODE


    public
        mixed
    CRYPT_RSA_MODE
    = constant($this->getOpenSslConstant())

CRYPT_RSA_MODE


    public
        mixed
    CRYPT_RSA_MODE
    = RSA::MODE_OPENSSL

false


    public
        mixed
    false
    = \true

IDNA_ALLOW_UNASSIGNED


    public
        mixed
    IDNA_ALLOW_UNASSIGNED
    = 1

IDNA_CHECK_BIDI


    public
        mixed
    IDNA_CHECK_BIDI
    = 4

IDNA_CHECK_CONTEXTJ


    public
        mixed
    IDNA_CHECK_CONTEXTJ
    = 8

IDNA_DEFAULT


    public
        mixed
    IDNA_DEFAULT
    = 0

IDNA_ERROR_BIDI


    public
        mixed
    IDNA_ERROR_BIDI
    = 2048

IDNA_ERROR_CONTEXTJ


    public
        mixed
    IDNA_ERROR_CONTEXTJ
    = 4096

IDNA_ERROR_DISALLOWED


    public
        mixed
    IDNA_ERROR_DISALLOWED
    = 128

IDNA_ERROR_DOMAIN_NAME_TOO_LONG


    public
        mixed
    IDNA_ERROR_DOMAIN_NAME_TOO_LONG
    = 4

IDNA_ERROR_EMPTY_LABEL


    public
        mixed
    IDNA_ERROR_EMPTY_LABEL
    = 1

IDNA_ERROR_HYPHEN_3_4


    public
        mixed
    IDNA_ERROR_HYPHEN_3_4
    = 32

IDNA_ERROR_INVALID_ACE_LABEL


    public
        mixed
    IDNA_ERROR_INVALID_ACE_LABEL
    = 1024

IDNA_ERROR_LABEL_HAS_DOT


    public
        mixed
    IDNA_ERROR_LABEL_HAS_DOT
    = 512

IDNA_ERROR_LABEL_TOO_LONG


    public
        mixed
    IDNA_ERROR_LABEL_TOO_LONG
    = 2

IDNA_ERROR_LEADING_COMBINING_MARK


    public
        mixed
    IDNA_ERROR_LEADING_COMBINING_MARK
    = 64

IDNA_ERROR_LEADING_HYPHEN


    public
        mixed
    IDNA_ERROR_LEADING_HYPHEN
    = 8

IDNA_ERROR_PUNYCODE


    public
        mixed
    IDNA_ERROR_PUNYCODE
    = 256

IDNA_ERROR_TRAILING_HYPHEN


    public
        mixed
    IDNA_ERROR_TRAILING_HYPHEN
    = 16

IDNA_NONTRANSITIONAL_TO_ASCII


    public
        mixed
    IDNA_NONTRANSITIONAL_TO_ASCII
    = 16

IDNA_NONTRANSITIONAL_TO_UNICODE


    public
        mixed
    IDNA_NONTRANSITIONAL_TO_UNICODE
    = 32

IDNA_USE_STD3_RULES


    public
        mixed
    IDNA_USE_STD3_RULES
    = 2

INTL_IDNA_VARIANT_2003


    public
        mixed
    INTL_IDNA_VARIANT_2003
    = 0

INTL_IDNA_VARIANT_UTS46


    public
        mixed
    INTL_IDNA_VARIANT_UTS46
    = 1

MATH_BIGINTEGER_OPENSSL_ENABLED


    public
        mixed
    MATH_BIGINTEGER_OPENSSL_ENABLED
    = true

MATH_BIGINTEGER_OPENSSL_ENABLED


    public
        mixed
    MATH_BIGINTEGER_OPENSSL_ENABLED
    = true

null


    public
        mixed
    null
    = \true

PHP_FLOAT_DIG


    public
        mixed
    PHP_FLOAT_DIG
    = 15

PHP_FLOAT_EPSILON


    public
        mixed
    PHP_FLOAT_EPSILON
    = 2.2204460492503E-16

PHP_FLOAT_MAX


    public
        mixed
    PHP_FLOAT_MAX
    = 1.7976931348623157E+308

PHP_FLOAT_MIN


    public
        mixed
    PHP_FLOAT_MIN
    = 2.2250738585072E-308

PHP_INT_MIN


    public
        mixed
    PHP_INT_MIN
    = ~\PHP_INT_MAX

PHP_OS_FAMILY


    public
        mixed
    PHP_OS_FAMILY
    = \Symfony\Polyfill\Php72\Php72::php_os_family()

PHP_VERSION_ID


    public
        mixed
    PHP_VERSION_ID
    = $RandomCompatversion[0] * 10000 + $RandomCompatversion[1] * 100 + $RandomCompatversion[2]

PHP_XMLRPC_COMPAT_DIR


    public
        mixed
    PHP_XMLRPC_COMPAT_DIR
    = \dirname(__FILE__) . '/compat/'

RANDOM_COMPAT_READ_BUFFER


    public
        mixed
    RANDOM_COMPAT_READ_BUFFER
    = 8

RANDOM_COMPAT_READ_BUFFER


    public
        mixed
    RANDOM_COMPAT_READ_BUFFER
    = 8

true


    public
        mixed
    true
    = \false

U_IDNA_ACE_PREFIX_ERROR


    public
        mixed
    U_IDNA_ACE_PREFIX_ERROR
    = 66564

U_IDNA_CHECK_BIDI_ERROR


    public
        mixed
    U_IDNA_CHECK_BIDI_ERROR
    = 66562

U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR


    public
        mixed
    U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR
    = 66568

U_IDNA_ERROR_LIMIT


    public
        mixed
    U_IDNA_ERROR_LIMIT
    = 66569

U_IDNA_ERROR_START


    public
        mixed
    U_IDNA_ERROR_START
    = 66560

U_IDNA_LABEL_TOO_LONG_ERROR


    public
        mixed
    U_IDNA_LABEL_TOO_LONG_ERROR
    = 66566

U_IDNA_PROHIBITED_ERROR


    public
        mixed
    U_IDNA_PROHIBITED_ERROR
    = 66560

U_IDNA_STD3_ASCII_RULES_ERROR


    public
        mixed
    U_IDNA_STD3_ASCII_RULES_ERROR
    = 66563

U_IDNA_UNASSIGNED_ERROR


    public
        mixed
    U_IDNA_UNASSIGNED_ERROR
    = 66561

U_IDNA_VERIFICATION_ERROR


    public
        mixed
    U_IDNA_VERIFICATION_ERROR
    = 66565

U_IDNA_ZERO_LENGTH_LABEL_ERROR


    public
        mixed
    U_IDNA_ZERO_LENGTH_LABEL_ERROR
    = 66567

U_STRINGPREP_CHECK_BIDI_ERROR


    public
        mixed
    U_STRINGPREP_CHECK_BIDI_ERROR
    = 66562

U_STRINGPREP_PROHIBITED_ERROR


    public
        mixed
    U_STRINGPREP_PROHIBITED_ERROR
    = 66560

U_STRINGPREP_UNASSIGNED_ERROR


    public
        mixed
    U_STRINGPREP_UNASSIGNED_ERROR
    = 66561

XMLRPC_EPI_ENABLED


    public
        mixed
    XMLRPC_EPI_ENABLED
    = '0'

htmLawed()


    
                    htmLawed(mixed $t[, mixed $C = 1 ][, mixed $S = array() ]) : mixed

Parameters

$t : mixed
$C : mixed = 1
$S : mixed = array()

hl_attrval()


    
                    hl_attrval(mixed $t, mixed $p) : mixed

Parameters

$t : mixed
$p : mixed

hl_bal()


    
                    hl_bal(mixed $t[, mixed $do = 1 ][, mixed $in = 'div' ]) : mixed

Parameters

$t : mixed
$do : mixed = 1
$in : mixed = 'div'

hl_cmtcd()


    
                    hl_cmtcd(mixed $t) : mixed

Parameters

$t : mixed

hl_ent()


    
                    hl_ent(mixed $t) : mixed

Parameters

$t : mixed

hl_prot()


    
                    hl_prot(mixed $p[, mixed $c = null ]) : mixed

Parameters

$p : mixed
$c : mixed = null

hl_regex()


    
                    hl_regex(mixed $p) : mixed

Parameters

$p : mixed

hl_spec()


    
                    hl_spec(mixed $t) : mixed

Parameters

$t : mixed

hl_tag()


    
                    hl_tag(mixed $t) : mixed

Parameters

$t : mixed

hl_tag2()


    
                    hl_tag2(mixed &$e, mixed &$a[, mixed $t = 1 ]) : mixed

Parameters

$e : mixed
$a : mixed
$t : mixed = 1

hl_tidy()


    
                    hl_tidy(mixed $t, mixed $w, mixed $p) : mixed

Parameters

$t : mixed
$w : mixed
$p : mixed

hl_version()


    
                    hl_version() : mixed

kses()


    
                    kses(mixed $t, mixed $h[, mixed $p = array('http', 'https', 'ftp', 'news', 'nntp', 'telnet', 'gopher', 'mailto') ]) : mixed

Parameters

$t : mixed
$h : mixed
$p : mixed = array('http', 'https', 'ftp', 'news', 'nntp', 'telnet', 'gopher', 'mailto')

kses_hook()


    
                    kses_hook(mixed $t, mixed &$C, mixed &$S) : mixed

Parameters

$t : mixed
$C : mixed
$S : mixed

composerRequire41ec22823faeb187c2fc8ae78a2d5464()


    
                    composerRequire41ec22823faeb187c2fc8ae78a2d5464(mixed $fileIdentifier, mixed $file) : mixed

Parameters

$fileIdentifier : mixed
$file : mixed

includeFile()

Scope isolated include.


    
                    includeFile(mixed $file) : mixed

Prevents access to $this/self from included files.

Parameters

$file : mixed

oauth2client_php_autoload()


    
                    oauth2client_php_autoload(mixed $className) : mixed

Parameters

$className : mixed

uri_template()

Expands a URI template


    
                    uri_template(string $template, array<string|int, mixed> $variables) : string

Parameters

$template : string: URI template
$variables : array<string|int, mixed>: Template variables

Return values

string

describe_type()

Debug function used to describe the provided value type and class.


    
                    describe_type(mixed $input) : string

Parameters

$input : mixed

Return values

string —

Returns a string containing the type of the variable and if a class is provided, the class name.

headers_from_lines()

Parses an array of header lines into an associative array of headers.


    
                    headers_from_lines(iterable<string|int, mixed> $lines) : array<string|int, mixed>

Parameters

$lines : iterable<string|int, mixed>: Header lines array of strings in the following format: "Name: Value"

Return values

array<string|int, mixed>

debug_resource()

Returns a debug stream based on the provided variable.


    
                    debug_resource([mixed $value = null ]) : resource

Parameters

$value : mixed = null: Optional value

Return values

resource

choose_handler()

Chooses and creates a default handler to use based on the environment.


    
                    choose_handler() : callable

The returned handler is not wrapped by any default middlewares.

Return values

callable —

Returns the best handler for the given system.

default_user_agent()

Get the default User-Agent string to use with Guzzle


    
                    default_user_agent() : string

Return values

string

default_ca_bundle()

Returns the default cacert bundle for the current system.


    
                    default_ca_bundle() : string

First, the openssl.cafile and curl.cainfo php.ini settings are checked. If those settings are not configured, then the common locations for bundles found on Red Hat, CentOS, Fedora, Ubuntu, Debian, FreeBSD, OS X and Windows are checked. If any of these file locations are found on disk, they will be utilized.

Note: the result of this function is cached for subsequent calls.

Return values

string

normalize_header_keys()

Creates an associative array of lowercase header names to the actual header casing.


    
                    normalize_header_keys(array<string|int, mixed> $headers) : array<string|int, mixed>

Parameters

$headers : array<string|int, mixed>

Return values

array<string|int, mixed>

is_host_in_noproxy()

Returns true if the provided host matches any of the no proxy areas.


    
                    is_host_in_noproxy(string $host, array<string|int, mixed> $noProxyArray) : bool

This method will strip a port from the host if it is present. Each pattern can be matched with an exact match (e.g., "foo.com" == "foo.com") or a partial match: (e.g., "foo.com" == "baz.foo.com" and ".foo.com" == "baz.foo.com", but ".foo.com" != "foo.com").

Areas are matched in the following cases:

"*" (without quotes) always matches any hosts.
An exact match.
The area starts with "." and the area is the last part of the host. e.g. '.mit.edu' will match any host that ends with '.mit.edu'.

Parameters

$host : string: Host to check against the patterns.
$noProxyArray : array<string|int, mixed>: An array of host patterns.

Return values

bool

json_decode()

Wrapper for json_decode that throws when an error occurs.


    
                    json_decode(string $json[, bool $assoc = false ][, int $depth = 512 ][, int $options = 0 ]) : mixed

Parameters

$json : string: JSON data to parse
$assoc : bool = false: When true, returned objects will be converted into associative arrays.
$depth : int = 512: User specified recursion depth.
$options : int = 0: Bitmask of JSON decode options.

json_encode()

Wrapper for JSON encoding that throws when an error occurs.


    
                    json_encode(mixed $value[, int $options = 0 ][, int $depth = 512 ]) : string

Parameters

$value : mixed: The value being encoded
$options : int = 0: JSON encode option bitmask
$depth : int = 512: Set the maximum depth. Must be greater than zero.

Return values

string

queue()

Get the global task queue used for promise resolution.

queue will be removed in guzzlehttp/promises:2.0. Use Utils::queue instead.


    
                    queue([TaskQueueInterface $assign = null ]) : TaskQueueInterface

This task queue MUST be run in an event loop in order for promises to be settled asynchronously. It will be automatically run when synchronously waiting on a promise.


while ($eventLoop->isRunning()) {
    GuzzleHttp\Promise\queue()->run();
}

Parameters

$assign : TaskQueueInterface = null: Optionally specify a new queue instance.

Return values

TaskQueueInterface

task()

Adds a function to run in the task queue when it is next `run()` and returns a promise that is fulfilled or rejected with the result.

task will be removed in guzzlehttp/promises:2.0. Use Utils::task instead.


    
                    task(callable $task) : PromiseInterface

Parameters

$task : callable: Task function to run.

Return values

PromiseInterface

promise_for()

Creates a promise for a value if the value is not a promise.

promise_for will be removed in guzzlehttp/promises:2.0. Use Create::promiseFor instead.


    
                    promise_for(mixed $value) : PromiseInterface

Parameters

$value : mixed: Promise or value.

Return values

PromiseInterface

rejection_for()

Creates a rejected promise for a reason if the reason is not a promise. If the provided reason is a promise, then it is returned as-is.

rejection_for will be removed in guzzlehttp/promises:2.0. Use Create::rejectionFor instead.


    
                    rejection_for(mixed $reason) : PromiseInterface

Parameters

$reason : mixed: Promise or reason.

Return values

PromiseInterface

exception_for()

Create an exception for a rejected promise value.

exception_for will be removed in guzzlehttp/promises:2.0. Use Create::exceptionFor instead.


    
                    exception_for(mixed $reason) : Exception|Throwable

Parameters

$reason : mixed

Return values

Exception|Throwable

iter_for()

Returns an iterator for the given value.

iter_for will be removed in guzzlehttp/promises:2.0. Use Create::iterFor instead.


    
                    iter_for(mixed $value) : Iterator

Parameters

$value : mixed

Return values

Iterator

inspect()

Synchronously waits on a promise to resolve and returns an inspection state array.

inspect will be removed in guzzlehttp/promises:2.0. Use Utils::inspect instead.


    
                    inspect(PromiseInterface $promise) : array<string|int, mixed>

Returns a state associative array containing a "state" key mapping to a valid promise state. If the state of the promise is "fulfilled", the array will contain a "value" key mapping to the fulfilled value of the promise. If the promise is rejected, the array will contain a "reason" key mapping to the rejection reason of the promise.

Parameters

$promise : PromiseInterface: Promise or value.

Return values

array<string|int, mixed>

inspect_all()

Waits on all of the provided promises, but does not unwrap rejected promises as thrown exception.

inspect will be removed in guzzlehttp/promises:2.0. Use Utils::inspectAll instead.


    
                    inspect_all(array<string|int, PromiseInterface> $promises) : array<string|int, mixed>

Returns an array of inspection state arrays.

Parameters

$promises : array<string|int, PromiseInterface>: Traversable of promises to wait upon.

Return values

array<string|int, mixed>

unwrap()

Waits on all of the provided promises and returns the fulfilled values.

unwrap will be removed in guzzlehttp/promises:2.0. Use Utils::unwrap instead.


    
                    unwrap(iterable<string|int, PromiseInterface> $promises) : array<string|int, mixed>

Returns an array that contains the value of each promise (in the same order the promises were provided). An exception is thrown if any of the promises are rejected.

Parameters

$promises : iterable<string|int, PromiseInterface>: Iterable of PromiseInterface objects to wait on.

Return values

array<string|int, mixed>

all()

Given an array of promises, return a promise that is fulfilled when all the items in the array are fulfilled.

all will be removed in guzzlehttp/promises:2.0. Use Utils::all instead.


    
                    all(mixed $promises[, bool $recursive = false ]) : PromiseInterface

The promise's fulfillment value is an array with fulfillment values at respective positions to the original array. If any promise in the array rejects, the returned promise is rejected with the rejection reason.

Parameters

$promises : mixed: Promises or values.
$recursive : bool = false: If true, resolves new promises that might have been added to the stack during its own resolution.

Return values

PromiseInterface

some()

Initiate a competitive race between multiple promises or values (values will become immediately fulfilled promises).

some will be removed in guzzlehttp/promises:2.0. Use Utils::some instead.


    
                    some(int $count, mixed $promises) : PromiseInterface

When count amount of promises have been fulfilled, the returned promise is fulfilled with an array that contains the fulfillment values of the winners in order of resolution.

This promise is rejected with a AggregateException if the number of fulfilled promises is less than the desired $count.

Parameters

$count : int: Total number of promises.
$promises : mixed: Promises or values.

Return values

PromiseInterface

any()

Like some(), with 1 as count. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.

any will be removed in guzzlehttp/promises:2.0. Use Utils::any instead.


    
                    any(mixed $promises) : PromiseInterface

Parameters

$promises : mixed: Promises or values.

Return values

PromiseInterface

settle()

Returns a promise that is fulfilled when all of the provided promises have been fulfilled or rejected.

settle will be removed in guzzlehttp/promises:2.0. Use Utils::settle instead.


    
                    settle(mixed $promises) : PromiseInterface

The returned promise is fulfilled with an array of inspection state arrays.

Parameters

$promises : mixed: Promises or values.

Return values

PromiseInterface

each()

Given an iterator that yields promises or values, returns a promise that is fulfilled with a null value when the iterator has been consumed or the aggregate promise has been fulfilled or rejected.

each will be removed in guzzlehttp/promises:2.0. Use Each::of instead.


    
                    each(mixed $iterable[, callable $onFulfilled = null ][, callable $onRejected = null ]) : PromiseInterface

$onFulfilled is a function that accepts the fulfilled value, iterator index, and the aggregate promise. The callback can invoke any necessary side effects and choose to resolve or reject the aggregate if needed.

$onRejected is a function that accepts the rejection reason, iterator index, and the aggregate promise. The callback can invoke any necessary side effects and choose to resolve or reject the aggregate if needed.

Parameters

$iterable : mixed: Iterator or array to iterate over.
$onFulfilled : callable = null
$onRejected : callable = null

Return values

PromiseInterface

each_limit()

Like each, but only allows a certain number of outstanding promises at any given time.

each_limit will be removed in guzzlehttp/promises:2.0. Use Each::ofLimit instead.


    
                    each_limit(mixed $iterable, int|callable $concurrency[, callable $onFulfilled = null ][, callable $onRejected = null ]) : PromiseInterface

$concurrency may be an integer or a function that accepts the number of pending promises and returns a numeric concurrency limit value to allow for dynamic a concurrency size.

Parameters

$iterable : mixed
$concurrency : int|callable
$onFulfilled : callable = null
$onRejected : callable = null

Return values

PromiseInterface

each_limit_all()

Like each_limit, but ensures that no promise in the given $iterable argument is rejected. If any promise is rejected, then the aggregate promise is rejected with the encountered rejection.

each_limit_all will be removed in guzzlehttp/promises:2.0. Use Each::ofLimitAll instead.


    
                    each_limit_all(mixed $iterable, int|callable $concurrency[, callable $onFulfilled = null ]) : PromiseInterface

Parameters

$iterable : mixed
$concurrency : int|callable
$onFulfilled : callable = null

Return values

PromiseInterface

is_fulfilled()

Returns true if a promise is fulfilled.

is_fulfilled will be removed in guzzlehttp/promises:2.0. Use Is::fulfilled instead.


    
                    is_fulfilled(PromiseInterface $promise) : bool

Parameters

$promise : PromiseInterface

Return values

bool

is_rejected()

Returns true if a promise is rejected.

is_rejected will be removed in guzzlehttp/promises:2.0. Use Is::rejected instead.


    
                    is_rejected(PromiseInterface $promise) : bool

Parameters

$promise : PromiseInterface

Return values

bool

is_settled()

Returns true if a promise is fulfilled or rejected.

is_settled will be removed in guzzlehttp/promises:2.0. Use Is::settled instead.


    
                    is_settled(PromiseInterface $promise) : bool

Parameters

$promise : PromiseInterface

Return values

bool

coroutine()

Create a new coroutine.

coroutine will be removed in guzzlehttp/promises:2.0. Use Coroutine::of instead.


    
                    coroutine(callable $generatorFn) : PromiseInterface

Parameters

$generatorFn : callable

Return values

PromiseInterface

str()

Returns the string representation of an HTTP message.

str will be removed in guzzlehttp/psr7:2.0. Use Message::toString instead.


    
                    str(MessageInterface $message) : string

Parameters

$message : MessageInterface: Message to convert to a string.

Return values

string

uri_for()

Returns a UriInterface for the given value.

uri_for will be removed in guzzlehttp/psr7:2.0. Use Utils::uriFor instead.


    
                    uri_for(string|UriInterface $uri) : UriInterface

This function accepts a string or UriInterface and returns a UriInterface for the given value. If the value is already a UriInterface, it is returned as-is.

Parameters

$uri : string|UriInterface

Return values

UriInterface

stream_for()

Create a new stream based on the input type.

stream_for will be removed in guzzlehttp/psr7:2.0. Use Utils::streamFor instead.


    
                    stream_for([resource|string|int|float|bool|StreamInterface|callable|Iterator|null $resource = '' ][, array<string|int, mixed> $options = [] ]) : StreamInterface

Options is an associative array that can contain the following keys:

metadata: Array of custom metadata.
size: Size of the stream.

This method accepts the following $resource types:

Psr\Http\Message\StreamInterface: Returns the value as-is.
string: Creates a stream object that uses the given string as the contents.
resource: Creates a stream object that wraps the given PHP stream resource.
Iterator: If the provided value implements Iterator, then a read-only stream object will be created that wraps the given iterable. Each time the stream is read from, data from the iterator will fill a buffer and will be continuously called until the buffer is equal to the requested read size. Subsequent read calls will first read from the buffer and then call next on the underlying iterator until it is exhausted.
object with __toString(): If the object has the __toString() method, the object will be cast to a string and then a stream will be returned that uses the string value.
NULL: When null is passed, an empty stream object is returned.
callable When a callable is passed, a read-only stream object will be created that invokes the given callable. The callable is invoked with the number of suggested bytes to read. The callable can return any number of bytes, but MUST return false when there is no more data to return. The stream object that wraps the callable will invoke the callable until the number of requested bytes are available. Any additional bytes will be buffered and used in subsequent reads.

Parameters

$resource : resource|string|int|float|bool|StreamInterface|callable|Iterator|null = '': Entity body data
$options : array<string|int, mixed> = []: Additional options

Return values

StreamInterface

parse_header()

Parse an array of header values containing ";" separated data into an array of associative arrays representing the header key value pair data of the header. When a parameter does not contain a value, but just contains a key, this function will inject a key with a '' string value.

parse_header will be removed in guzzlehttp/psr7:2.0. Use Header::parse instead.


    
                    parse_header(string|array<string|int, mixed> $header) : array<string|int, mixed>

Parameters

$header : string|array<string|int, mixed>: Header to parse into components.

Return values

array<string|int, mixed> —

Returns the parsed header values.

normalize_header()

Converts an array of header values that may contain comma separated headers into an array of headers with no comma separated values.

normalize_header will be removed in guzzlehttp/psr7:2.0. Use Header::normalize instead.


    
                    normalize_header(string|array<string|int, mixed> $header) : array<string|int, mixed>

Parameters

$header : string|array<string|int, mixed>: Header to normalize.

Return values

array<string|int, mixed> —

Returns the normalized header field values.

modify_request()

Clone and modify a request with the given changes.

modify_request will be removed in guzzlehttp/psr7:2.0. Use Utils::modifyRequest instead.


    
                    modify_request(RequestInterface $request, array<string|int, mixed> $changes) : RequestInterface

This method is useful for reducing the number of clones needed to mutate a message.

The changes can be one of:

method: (string) Changes the HTTP method.
set_headers: (array) Sets the given headers.
remove_headers: (array) Remove the given headers.
body: (mixed) Sets the given body.
uri: (UriInterface) Set the URI.
query: (string) Set the query string value of the URI.
version: (string) Set the protocol version.

Parameters

$request : RequestInterface: Request to clone and modify.
$changes : array<string|int, mixed>: Changes to apply.

Return values

RequestInterface

rewind_body()

Attempts to rewind a message body and throws an exception on failure.

rewind_body will be removed in guzzlehttp/psr7:2.0. Use Message::rewindBody instead.


    
                    rewind_body(MessageInterface $message) : mixed

The body of the message will only be rewound if a call to tell() returns a value other than 0.

Parameters

$message : MessageInterface: Message to rewind

try_fopen()

Safely opens a PHP stream resource using a filename.

try_fopen will be removed in guzzlehttp/psr7:2.0. Use Utils::tryFopen instead.


    
                    try_fopen(string $filename, string $mode) : resource

When fopen fails, PHP normally raises a warning. This function adds an error handler that checks for errors and throws an exception instead.

Parameters

$filename : string: File to open
$mode : string: Mode used to open the file

Return values

resource

copy_to_string()

Copy the contents of a stream into a string until the given number of bytes have been read.

copy_to_string will be removed in guzzlehttp/psr7:2.0. Use Utils::copyToString instead.


    
                    copy_to_string(StreamInterface $stream[, int $maxLen = -1 ]) : string

Parameters

$stream : StreamInterface: Stream to read
$maxLen : int = -1: Maximum number of bytes to read. Pass -1 to read the entire stream.

Return values

string

copy_to_stream()

Copy the contents of a stream into another stream until the given number of bytes have been read.

copy_to_stream will be removed in guzzlehttp/psr7:2.0. Use Utils::copyToStream instead.


    
                    copy_to_stream(StreamInterface $source, StreamInterface $dest[, int $maxLen = -1 ]) : mixed

Parameters

$source : StreamInterface: Stream to read from
$dest : StreamInterface: Stream to write to
$maxLen : int = -1: Maximum number of bytes to read. Pass -1 to read the entire stream.

hash()

Calculate a hash of a stream.

hash will be removed in guzzlehttp/psr7:2.0. Use Utils::hash instead.


    
                    hash(StreamInterface $stream, string $algo[, bool $rawOutput = false ]) : string

This method reads the entire stream to calculate a rolling hash, based on PHP's hash_init functions.

Parameters

$stream : StreamInterface: Stream to calculate the hash for
$algo : string: Hash algorithm (e.g. md5, crc32, etc)
$rawOutput : bool = false: Whether or not to use raw output

Return values

string —

Returns the hash of the stream

readline()

Read a line from the stream up to the maximum allowed buffer length.

readline will be removed in guzzlehttp/psr7:2.0. Use Utils::readLine instead.


    
                    readline(StreamInterface $stream[, int|null $maxLength = null ]) : string

Parameters

$stream : StreamInterface: Stream to read from
$maxLength : int|null = null: Maximum buffer length

Return values

string

parse_request()

Parses a request message string into a request object.

parse_request will be removed in guzzlehttp/psr7:2.0. Use Message::parseRequest instead.


    
                    parse_request(string $message) : Request

Parameters

$message : string: Request message string.

Return values

Request

parse_response()

Parses a response message string into a response object.

parse_response will be removed in guzzlehttp/psr7:2.0. Use Message::parseResponse instead.


    
                    parse_response(string $message) : Response

Parameters

$message : string: Response message string.

Return values

Response

parse_query()

Parse a query string into an associative array.

parse_query will be removed in guzzlehttp/psr7:2.0. Use Query::parse instead.


    
                    parse_query(string $str[, int|bool $urlEncoding = true ]) : array<string|int, mixed>

If multiple values are found for the same key, the value of that key value pair will become an array. This function does not parse nested PHP style arrays into an associative array (e.g., foo[a]=1&foo[b]=2 will be parsed into ['foo[a]' => '1', 'foo[b]' => '2']).

Parameters

$str : string: Query string to parse
$urlEncoding : int|bool = true: How the query string is encoded

Return values

array<string|int, mixed>

build_query()

Build a query string from an array of key value pairs.

build_query will be removed in guzzlehttp/psr7:2.0. Use Query::build instead.


    
                    build_query(array<string|int, mixed> $params[, int|false $encoding = PHP_QUERY_RFC3986 ]) : string

This function can use the return value of parse_query() to build a query string. This function does not modify the provided keys when an array is encountered (like http_build_query() would).

Parameters

$params : array<string|int, mixed>: Query string parameters.
$encoding : int|false = PHP_QUERY_RFC3986: Set to false to not encode, PHP_QUERY_RFC3986 to encode using RFC3986, or PHP_QUERY_RFC1738 to encode using RFC1738.

Return values

string

mimetype_from_filename()

Determines the mimetype of a file by looking at its extension.

mimetype_from_filename will be removed in guzzlehttp/psr7:2.0. Use MimeType::fromFilename instead.


    
                    mimetype_from_filename(string $filename) : string|null

Parameters

$filename : string

Return values

string|null

mimetype_from_extension()

Maps a file extensions to a mimetype.

mimetype_from_extension will be removed in guzzlehttp/psr7:2.0. Use MimeType::fromExtension instead.


    
                    mimetype_from_extension(mixed $extension) : string|null

Parameters

$extension : mixed: string The file extension.

Return values

string|null

get_message_body_summary()

Get a short summary of the message body.

get_message_body_summary will be removed in guzzlehttp/psr7:2.0. Use Message::bodySummary instead.


    
                    get_message_body_summary(MessageInterface $message[, int $truncateAt = 120 ]) : string|null

Will return null if the response is not printable.

Parameters

$message : MessageInterface: The message to get the body summary
$truncateAt : int = 120: The maximum allowed size of the summary

Return values

string|null

RandomCompat_strlen()

strlen() implementation that isn't brittle to mbstring.func_overload


    
                    RandomCompat_strlen(string $binary_string) : int

This version just used the default strlen()

Parameters

$binary_string : string

Return values

int

RandomCompat_substr()

substr() implementation that isn't brittle to mbstring.func_overload


    
                    RandomCompat_substr(string $binary_string, int $start[, int|null $length = null ]) : string

This version just uses the default substr()

Parameters

$binary_string : string
$start : int
$length : int|null = null: (optional)

Return values

string

RandomCompat_intval()

Cast to an integer if we can, safely.


    
                    RandomCompat_intval(int|float $number[, bool $fail_open = false ]) : float|int

If you pass it a float in the range (~PHP_INT_MAX, PHP_INT_MAX) (non-inclusive), it will sanely cast it to an int. If you it's equal to ~PHP_INT_MAX or PHP_INT_MAX, we let it fail as not an integer. Floats lose precision, so the <= and => operators might accidentally let a float through.

Parameters

$number : int|float: The number we want to convert to an int
$fail_open : bool = false: Set to true to not throw an exception

Return values

float|int

random_bytes()

We don't have any more options, so let's throw an exception right now and hope the developer won't let it fail silently.


    
                    random_bytes(mixed $length) : string

Parameters

$length : mixed

Return values

string

random_bytes()

Windows with PHP < 5.3.0 will not have the function openssl_random_pseudo_bytes() available, so let's use CAPICOM to work around this deficiency.


    
                    random_bytes(int $bytes) : string

Parameters

$bytes : int

Return values

string

random_bytes()

Unless open_basedir is enabled, use /dev/urandom for random numbers in accordance with best practices


    
                    random_bytes(int $bytes) : string

Why we use /dev/urandom and not /dev/random

Parameters

$bytes : int

Return values

string

random_bytes()

If the libsodium PHP extension is loaded, we'll use it above any other solution.


    
                    random_bytes(int $bytes) : string

libsodium-php project:

Parameters

$bytes : int

Return values

string

random_bytes()

If the libsodium PHP extension is loaded, we'll use it above any other solution.


    
                    random_bytes(int $bytes) : string

libsodium-php project:

Parameters

$bytes : int

Return values

string

random_bytes()


    
                    random_bytes(int $bytes) : string

Parameters

$bytes : int

Return values

string

random_int()

Fetch a random integer between $min and $max inclusive


    
                    random_int(int $min, int $max) : int

Parameters

$min : int
$max : int

Return values

int

getallheaders()

Get all HTTP header key/values as an associative array for the current request.


    
                    getallheaders() : mixed

Return values

mixed —

The HTTP header key/value pairs.

idn_to_ascii()


    
                    idn_to_ascii(mixed $domain[, mixed $options = IDNA_DEFAULT ][, mixed $variant = INTL_IDNA_VARIANT_UTS46 ][, mixed &$idna_info = array() ]) : mixed

Parameters

$domain : mixed
$options : mixed = IDNA_DEFAULT
$variant : mixed = INTL_IDNA_VARIANT_UTS46
$idna_info : mixed = array()

idn_to_utf8()


    
                    idn_to_utf8(mixed $domain[, mixed $options = IDNA_DEFAULT ][, mixed $variant = INTL_IDNA_VARIANT_UTS46 ][, mixed &$idna_info = array() ]) : mixed

Parameters

$domain : mixed
$options : mixed = IDNA_DEFAULT
$variant : mixed = INTL_IDNA_VARIANT_UTS46
$idna_info : mixed = array()

normalizer_is_normalized()


    
                    normalizer_is_normalized(mixed $input[, mixed $form = pNormalizer::NFC ]) : mixed

Parameters

$input : mixed
$form : mixed = pNormalizer::NFC

normalizer_normalize()


    
                    normalizer_normalize(mixed $input[, mixed $form = pNormalizer::NFC ]) : mixed

Parameters

$input : mixed
$form : mixed = pNormalizer::NFC

intdiv()


    
                    intdiv(mixed $dividend, mixed $divisor) : mixed

Parameters

$dividend : mixed
$divisor : mixed

preg_replace_callback_array()


    
                    preg_replace_callback_array(array<string|int, mixed> $patterns, mixed $subject[, mixed $limit = -1 ][, mixed &$count = 0 ]) : mixed

Parameters

$patterns : array<string|int, mixed>
$subject : mixed
$limit : mixed = -1
$count : mixed = 0

error_clear_last()


    
                    error_clear_last() : mixed

sapi_windows_vt100_support()


    
                    sapi_windows_vt100_support(mixed $stream[, mixed $enable = null ]) : mixed

Parameters

$stream : mixed
$enable : mixed = null

stream_isatty()


    
                    stream_isatty(mixed $stream) : mixed

Parameters

$stream : mixed

utf8_encode()


    
                    utf8_encode(mixed $string) : mixed

Parameters

$string : mixed

utf8_decode()


    
                    utf8_decode(mixed $string) : mixed

Parameters

$string : mixed

spl_object_id()


    
                    spl_object_id(mixed $object) : mixed

Parameters

$object : mixed

mb_ord()


    
                    mb_ord(mixed $string[, mixed $encoding = null ]) : mixed

Parameters

$string : mixed
$encoding : mixed = null

mb_chr()


    
                    mb_chr(mixed $codepoint[, mixed $encoding = null ]) : mixed

Parameters

$codepoint : mixed
$encoding : mixed = null

mb_scrub()


    
                    mb_scrub(mixed $string[, mixed $encoding = null ]) : mixed

Parameters

$string : mixed
$encoding : mixed = null

xmlrpc_encode_entitites()

Convert a string to the correct XML representation in a target charset To help correct communication of non-ascii chars inside strings, regardless of the charset used when sending requests, parsing them, sending responses and parsing responses, an option is to convert all non-ascii chars present in the message into their equivalent 'charset entity'. Charset entities enumerated this way are independent of the charset encoding used to transmit them, and all XML parsers are bound to understand them.


    
                    xmlrpc_encode_entitites(mixed $data[, mixed $src_encoding = '' ][, mixed $dest_encoding = '' ]) : mixed

Note that in the std case we are not sending a charset encoding mime type along with http headers, so we are bound by RFC 3023 to emit strict us-ascii.

Parameters

$data : mixed
$src_encoding : mixed = ''
$dest_encoding : mixed = ''

xmlrpc_se()


    
                    xmlrpc_se(mixed $parser, mixed $name, mixed $attrs[, mixed $accept_single_vals = false ]) : mixed

Parameters

$parser : mixed
$name : mixed
$attrs : mixed
$accept_single_vals : mixed = false

xmlrpc_se_any()


    
                    xmlrpc_se_any(mixed $parser, mixed $name, mixed $attrs) : mixed

Parameters

$parser : mixed
$name : mixed
$attrs : mixed

xmlrpc_ee()


    
                    xmlrpc_ee(mixed $parser, mixed $name[, mixed $rebuild_xmlrpcvals = true ]) : mixed

Parameters

$parser : mixed
$name : mixed
$rebuild_xmlrpcvals : mixed = true

xmlrpc_ee_fast()


    
                    xmlrpc_ee_fast(mixed $parser, mixed $name) : mixed

Parameters

$parser : mixed
$name : mixed

xmlrpc_cd()


    
                    xmlrpc_cd(mixed $parser, mixed $data) : mixed

Parameters

$parser : mixed
$data : mixed

xmlrpc_dh()


    
                    xmlrpc_dh(mixed $parser, mixed $data) : mixed

Parameters

$parser : mixed
$data : mixed

iso8601_encode()

Given a timestamp, return the corresponding ISO8601 encoded string.


    
                    iso8601_encode(int $timet[, int $utc = 0 ]) : string

Really, timezones ought to be supported but the XML-RPC spec says:

"Don't assume a timezone. It should be specified by the server in its documentation what assumptions it makes about timezones."

These routines always assume localtime unless $utc is set to 1, in which case UTC is assumed and an adjustment for locale is made when encoding

Parameters

$timet : int: (timestamp)
$utc : int = 0: (0 or 1)

Return values

string

iso8601_decode()

Given an ISO8601 date string, return a timet in the localtime, or UTC


    
                    iso8601_decode(string $idate[, int $utc = 0 ]) : int

Parameters

$idate : string
$utc : int = 0: either 0 or 1

Return values

int —

(datetime)

php_xmlrpc_decode()

Takes an xmlrpc value in PHP xmlrpcval object format and translates it into native PHP types.


    
                    php_xmlrpc_decode(xmlrpcval $xmlrpc_val[, array<string|int, mixed> $options = array() ]) : mixed

Works with xmlrpc message objects as input, too.

Given proper options parameter, can rebuild generic php object instances (provided those have been encoded to xmlrpc format using a corresponding option in php_xmlrpc_encode()) PLEASE NOTE that rebuilding php objects involves calling their constructor function. This means that the remote communication end can decide which php code will get executed on your server, leaving the door possibly open to 'php-injection' style of attacks (provided you have some classes defined on your server that might wreak havoc if instances are built outside an appropriate context). Make sure you trust the remote server/client before eanbling this!

Parameters

$xmlrpc_val : xmlrpcval
$options : array<string|int, mixed> = array(): if 'decode_php_objs' is set in the options array, xmlrpc structs can be decoded into php objects

php_xmlrpc_encode()

Takes native php types and encodes them into xmlrpc PHP object format.


    
                &    php_xmlrpc_encode(mixed $php_val[, array<string|int, mixed> $options = array() ]) : xmlrpcval

It will not re-encode xmlrpcval objects.

Feature creep -- could support more types via optional type argument (string => datetime support has been added, ??? => base64 not yet)

If given a proper options parameter, php object instances will be encoded into 'special' xmlrpc values, that can later be decoded into php objects by calling php_xmlrpc_decode() with a corresponding option

Parameters

$php_val : mixed: the value to be converted into an xmlrpcval object
$options : array<string|int, mixed> = array(): can include 'encode_php_objs', 'auto_dates', 'null_extension' or 'extension_api'

Return values

xmlrpcval

php_xmlrpc_decode_xml()

Convert the xml representation of a method response, method request or single xmlrpc value into the appropriate object (a.k.a. deserialize)


    
                    php_xmlrpc_decode_xml(string $xml_val[, array<string|int, mixed> $options = array() ]) : mixed

Parameters

$xml_val : string
$options : array<string|int, mixed> = array()

Return values

mixed —

false on error, or an instance of either xmlrpcval, xmlrpcmsg or xmlrpcresp

decode_chunked()

decode a string that is encoded w/ "chunked" transfer encoding as defined in rfc2068 par. 19.4.6 code shamelessly stolen from nusoap library by Dietrich Ayala


    
                    decode_chunked(string $buffer) : string

Parameters

$buffer : string: the string to be decoded

Return values

string

guess_encoding()

xml charset encoding guessing helper function.


    
                    guess_encoding([mixed $httpheader = '' ][, string $xmlchunk = '' ][, string $encoding_prefs = null ]) : mixed

Tries to determine the charset encoding of an XML chunk received over HTTP. NB: according to the spec (RFC 3023, if text/xml content-type is received over HTTP without a content-type, we SHOULD assume it is strictly US-ASCII. But we try to be more tolerant of unconforming (legacy?) clients/servers, which will be most probably using UTF-8 anyway...

Parameters

$httpheader : mixed = ''
$xmlchunk : string = '': xml content buffer
$encoding_prefs : string = null: comma separated list of character encodings to be used as default (when mb extension is enabled)

is_valid_charset()

Checks if a given charset encoding is present in a list of encodings or if it is a valid subset of any encoding in the list


    
                    is_valid_charset(string $encoding, mixed $validlist) : mixed

Parameters

$encoding : string: charset to be tested
$validlist : mixed: comma separated list of valid charsets (or array of charsets)

_xmlrpcs_getCapabilities()


    
                    _xmlrpcs_getCapabilities(mixed $server[, mixed $m = null ]) : mixed

Parameters

$server : mixed
$m : mixed = null

_xmlrpcs_listMethods()


    
                    _xmlrpcs_listMethods(mixed $server[, mixed $m = null ]) : mixed

Parameters

$server : mixed
$m : mixed = null

_xmlrpcs_methodSignature()


    
                    _xmlrpcs_methodSignature(mixed $server, mixed $m) : mixed

Parameters

$server : mixed
$m : mixed

_xmlrpcs_methodHelp()


    
                    _xmlrpcs_methodHelp(mixed $server, mixed $m) : mixed

Parameters

$server : mixed
$m : mixed

_xmlrpcs_multicall_error()


    
                    _xmlrpcs_multicall_error(mixed $err) : mixed

Parameters

$err : mixed

_xmlrpcs_multicall_do_call()


    
                    _xmlrpcs_multicall_do_call(mixed $server, mixed $call) : mixed

Parameters

$server : mixed
$call : mixed

_xmlrpcs_multicall_do_call_phpvals()


    
                    _xmlrpcs_multicall_do_call_phpvals(mixed $server, mixed $call) : mixed

Parameters

$server : mixed
$call : mixed

_xmlrpcs_multicall()


    
                    _xmlrpcs_multicall(mixed $server, mixed $m) : mixed

Parameters

$server : mixed
$m : mixed

_xmlrpcs_errorHandler()

Error handler used to track errors that occur during server-side execution of PHP code.


    
                    _xmlrpcs_errorHandler(mixed $errcode, mixed $errstring[, mixed $filename = null ][, mixed $lineno = null ][, mixed $context = null ]) : mixed

This allows to report back to the client whether an internal error has occurred or not using an xmlrpc response object, instead of letting the client deal with the html junk that a PHP execution error on the server generally entails.

NB: in fact a user defined error handler can only handle WARNING, NOTICE and USER_* errors.

Parameters

$errcode : mixed
$errstring : mixed
$filename : mixed = null
$lineno : mixed = null
$context : mixed = null

xmlrpc_debugmsg()

Add a string to the debug info that can be later seralized by the server as part of the response message.


    
                    xmlrpc_debugmsg(string $m) : mixed

Note that for best compatbility, the debug string should be encoded using the $GLOBALS['xmlrpc_internalencoding'] character set.

Parameters

$m : string

Application

Table of Contents

Interfaces

Classes

Traits

Constants

Functions

Constants

CRYPT_RSA_MODE

CRYPT_RSA_MODE

false

IDNA_ALLOW_UNASSIGNED

IDNA_CHECK_BIDI

IDNA_CHECK_CONTEXTJ

IDNA_DEFAULT

IDNA_ERROR_BIDI

IDNA_ERROR_CONTEXTJ

IDNA_ERROR_DISALLOWED

IDNA_ERROR_DOMAIN_NAME_TOO_LONG

IDNA_ERROR_EMPTY_LABEL

IDNA_ERROR_HYPHEN_3_4

IDNA_ERROR_INVALID_ACE_LABEL

IDNA_ERROR_LABEL_HAS_DOT

IDNA_ERROR_LABEL_TOO_LONG

IDNA_ERROR_LEADING_COMBINING_MARK

IDNA_ERROR_LEADING_HYPHEN

IDNA_ERROR_PUNYCODE

IDNA_ERROR_TRAILING_HYPHEN

IDNA_NONTRANSITIONAL_TO_ASCII

IDNA_NONTRANSITIONAL_TO_UNICODE

IDNA_USE_STD3_RULES

INTL_IDNA_VARIANT_2003

INTL_IDNA_VARIANT_UTS46

MATH_BIGINTEGER_OPENSSL_ENABLED

MATH_BIGINTEGER_OPENSSL_ENABLED

null

PHP_FLOAT_DIG

PHP_FLOAT_EPSILON

PHP_FLOAT_MAX

PHP_FLOAT_MIN

PHP_INT_MIN

PHP_OS_FAMILY

PHP_VERSION_ID

PHP_XMLRPC_COMPAT_DIR

RANDOM_COMPAT_READ_BUFFER

RANDOM_COMPAT_READ_BUFFER

true

U_IDNA_ACE_PREFIX_ERROR

U_IDNA_CHECK_BIDI_ERROR

U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR

U_IDNA_ERROR_LIMIT

U_IDNA_ERROR_START

U_IDNA_LABEL_TOO_LONG_ERROR

U_IDNA_PROHIBITED_ERROR

U_IDNA_STD3_ASCII_RULES_ERROR

U_IDNA_UNASSIGNED_ERROR

U_IDNA_VERIFICATION_ERROR

U_IDNA_ZERO_LENGTH_LABEL_ERROR

U_STRINGPREP_CHECK_BIDI_ERROR

U_STRINGPREP_PROHIBITED_ERROR

U_STRINGPREP_UNASSIGNED_ERROR

XMLRPC_EPI_ENABLED

Functions

htmLawed()