create-prisma-php-app 1.0.0

package/vendor/ramsey/uuid/docs/reference/uuidfactoryinterface.rst

@@ -0,0 +1,102 @@
+.. _reference.uuidfactoryinterface:
+
+====================
+UuidFactoryInterface
+====================
+
+.. php:namespace:: Ramsey\Uuid
+
+.. php:interface:: UuidFactoryInterface
+
+    Represents a UUID factory.
+
+    .. php:method:: getValidator()
+
+        :returntype: Ramsey\\Uuid\\Validator\\ValidatorInterface
+
+    .. php:method:: uuid1([$node[, $clockSeq]])
+
+        Generates a version 1, Gregorian time UUID. See :ref:`rfc4122.version1`.
+
+        :param Ramsey\\Uuid\\Type\\Hexadecimal|null $node: An optional hexadecimal node to use
+        :param int|null $clockSeq: An optional clock sequence to use
+        :returns: A version 1 UUID
+        :returntype: Ramsey\\Uuid\\Rfc4122\\UuidV1
+
+    .. php:method:: uuid2($localDomain[, $localIdentifier[, $node[, $clockSeq]]])
+
+        Generates a version 2, DCE Security UUID. See :ref:`rfc4122.version2`.
+
+        :param int $localDomain: The local domain to use (one of :php:const:`Uuid::DCE_DOMAIN_PERSON`, :php:const:`Uuid::DCE_DOMAIN_GROUP`, or :php:const:`Uuid::DCE_DOMAIN_ORG`)
+        :param Ramsey\\Uuid\\Type\\Integer|null $localIdentifier: A local identifier for the domain (defaults to system UID or GID for *person* or *group*)
+        :param Ramsey\\Uuid\\Type\\Hexadecimal|null $node: An optional hexadecimal node to use
+        :param int|null $clockSeq: An optional clock sequence to use
+        :returns: A version 2 UUID
+        :returntype: Ramsey\\Uuid\\Rfc4122\\UuidV2
+
+    .. php:method:: uuid3($ns, $name)
+
+        Generates a version 3, name-based (MD5) UUID. See :ref:`rfc4122.version3`.
+
+        :param Ramsey\\Uuid\\UuidInterface|string $ns: The namespace for this identifier
+        :param string $name: The name from which to generate an identifier
+        :returns: A version 3 UUID
+        :returntype: Ramsey\\Uuid\\Rfc4122\\UuidV3
+
+    .. php:method:: uuid4()
+
+        Generates a version 4, random UUID. See :ref:`rfc4122.version4`.
+
+        :returns: A version 4 UUID
+        :returntype: Ramsey\\Uuid\\Rfc4122\\UuidV4
+
+    .. php:method:: uuid5($ns, $name)
+
+        Generates a version 5, name-based (SHA-1) UUID. See :ref:`rfc4122.version5`.
+
+        :param Ramsey\\Uuid\\UuidInterface|string $ns: The namespace for this identifier
+        :param string $name: The name from which to generate an identifier
+        :returns: A version 5 UUID
+        :returntype: Ramsey\\Uuid\\Rfc4122\\UuidV5
+
+    .. php:method:: uuid6([$node[, $clockSeq]])
+
+        Generates a version 6, reordered time UUID. See :ref:`rfc4122.version6`.
+
+        :param Ramsey\\Uuid\\Type\\Hexadecimal|null $node: An optional hexadecimal node to use
+        :param int|null $clockSeq: An optional clock sequence to use
+        :returns: A version 6 UUID
+        :returntype: Ramsey\\Uuid\\Rfc4122\\UuidV6
+
+    .. php:method:: fromString($uuid)
+
+        Creates an instance of UuidInterface from the string standard
+        representation.
+
+        :param string $uuid: The string standard representation of a UUID
+        :returntype: Ramsey\\Uuid\\UuidInterface
+
+    .. php:method:: fromBytes($bytes)
+
+        Creates an instance of UuidInterface from a 16-byte string.
+
+        :param string $bytes: A 16-byte binary string representation of a UUID
+        :returntype: Ramsey\\Uuid\\UuidInterface
+
+    .. php:method:: fromInteger($integer)
+
+        Creates an instance of UuidInterface from a 128-bit string integer.
+
+        :param string $integer: A 128-bit string integer representation of a UUID
+        :returntype: Ramsey\\Uuid\\UuidInterface
+
+    .. php:method:: fromDateTime($dateTime[, $node[, $clockSeq]])
+
+        Creates a version 1 UUID instance from a `DateTimeInterface
+        <https://www.php.net/datetimeinterface>`_ instance.
+
+        :param DateTimeInterface $dateTime: The date from which to create the UUID instance
+        :param Ramsey\\Uuid\\Type\\Hexadecimal|null $node: An optional hexadecimal node to use
+        :param int|null $clockSeq: An optional clock sequence to use
+        :returns: A version 1 UUID
+        :returntype: Ramsey\\Uuid\\Rfc4122\\UuidV1

package/vendor/ramsey/uuid/docs/reference/uuidinterface.rst

@@ -0,0 +1,60 @@
+.. _reference.uuidinterface:
+
+=============
+UuidInterface
+=============
+
+.. php:namespace:: Ramsey\Uuid
+
+.. php:interface:: UuidInterface
+
+    Represents a UUID.
+
+    .. php:method:: compareTo($other)
+
+        :param Ramsey\\Uuid\\UuidInterface $other: The UUID to compare
+        :returns: Returns ``-1``, ``0``, or ``1`` if the UUID is less than, equal to, or greater than the other UUID.
+        :returntype: ``int``
+
+    .. php:method:: equals($other)
+
+        :param object|null $other: An object to test for equality with this UUID.
+        :returns: Returns true if the UUID is equal to the provided object.
+        :returntype: ``bool``
+
+    .. php:method:: getBytes()
+
+        :returns: A binary string representation of the UUID.
+        :returntype: ``string``
+
+    .. php:method:: getFields()
+
+        :returns: The fields that comprise this UUID.
+        :returntype: Ramsey\\Uuid\\Fields\\FieldsInterface
+
+    .. php:method:: getHex()
+
+        :returns: The hexadecimal representation of the UUID.
+        :returntype: Ramsey\\Uuid\\Type\\Hexadecimal
+
+    .. php:method:: getInteger()
+
+        :returns: The integer representation of the UUID.
+        :returntype: Ramsey\\Uuid\\Type\\Integer
+
+    .. php:method:: getUrn()
+
+        :returns: The string standard representation of the UUID as a `URN`_.
+        :returntype: ``string``
+
+    .. php:method:: toString()
+
+        :returns: The string standard representation of the UUID.
+        :returntype: ``string``
+
+    .. php:method:: __toString()
+
+        :returns: The string standard representation of the UUID.
+        :returntype: ``string``
+
+.. _URN: https://tools.ietf.org/html/rfc8141

package/vendor/ramsey/uuid/docs/reference/validators.rst

@@ -0,0 +1,34 @@
+.. _reference.validators:
+
+==========
+Validators
+==========
+
+.. php:namespace:: Ramsey\Uuid\Validator
+
+.. php:interface:: ValidatorInterface
+
+    .. php:method:: getPattern()
+
+        :returns: The regular expression pattern used by this validator
+        :returntype: ``string``
+
+    .. php:method:: validate($uuid)
+
+        :param string $uuid: The string to validate as a UUID
+        :returns: True if the provided string represents a UUID, false otherwise
+        :returntype: ``bool``
+
+.. php:class:: GenericValidator
+
+    Implements :php:interface:`Ramsey\\Uuid\\Validator\\ValidatorInterface`.
+
+    GenericValidator validates strings as UUIDs of any variant.
+
+.. php:namespace:: Ramsey\Uuid\Rfc4122
+
+.. php:class:: Validator
+
+    Implements :php:interface:`Ramsey\\Uuid\\Validator\\ValidatorInterface`.
+
+    Rfc4122\Validator validates strings as UUIDs of the RFC 4122 variant.

package/vendor/ramsey/uuid/docs/reference/variant.rst

@@ -0,0 +1,32 @@
+.. _reference.variant:
+
+=======
+Variant
+=======
+
+.. php:namespace:: Ramsey\Uuid
+
+.. php:enum:: Variant : int
+
+    The variant number describes the layout of the UUID. UUIDs generated
+    according to the layout defined in `RFC 4122`_ will always have a variant
+    value set to ``2``. In ramsey/uuid, this is the enum value
+    :php:case:`Ramsey\\Uuid\\Variant::Rfc4122`.
+
+    .. php:case:: ReservedNcs : 0
+
+        Reserved for NCS backward compatibility.
+
+    .. php:case:: Rfc4122 : 2
+
+        The RFC 4122 variant.
+
+    .. php:case:: ReservedMicrosoft : 6
+
+        Reserved for Microsoft Corporation backward compatibility.
+
+    .. php:case:: ReservedFuture : 7
+
+        Reserved for future definition.
+
+.. _RFC 4122: https://www.rfc-editor.org/rfc/rfc4122

package/vendor/ramsey/uuid/docs/reference.rst

@@ -0,0 +1,37 @@
+.. _reference:
+
+=========
+Reference
+=========
+
+.. toctree::
+    :titlesonly:
+
+    reference/uuid
+    reference/uuidinterface
+    reference/timebaseduuidinterface
+    reference/fields-fieldsinterface
+    reference/rfc4122-uuidinterface
+    reference/rfc4122-fieldsinterface
+    reference/rfc4122-uuidv1
+    reference/rfc4122-uuidv2
+    reference/rfc4122-uuidv3
+    reference/rfc4122-uuidv4
+    reference/rfc4122-uuidv5
+    reference/rfc4122-uuidv6
+    reference/rfc4122-uuidv7
+    reference/rfc4122-uuidv8
+    reference/rfc4122-version
+    reference/guid-fields
+    reference/guid-guid
+    reference/nonstandard-fields
+    reference/nonstandard-uuid
+    reference/nonstandard-uuidv6
+    reference/uuidfactoryinterface
+    reference/types
+    reference/exceptions
+    reference/helper
+    reference/name-based-namespaces
+    reference/calculators
+    reference/validators
+    reference/variant

package/vendor/ramsey/uuid/docs/requirements.txt

@@ -0,0 +1,3 @@
+Sphinx==4.5.0
+sphinx-rtd-theme==1.0.0
+sphinxcontrib-phpdomain==0.9.0

package/vendor/ramsey/uuid/docs/rfc4122/version1.rst

@@ -0,0 +1,192 @@
+.. _rfc4122.version1:
+
+=========================
+Version 1: Gregorian Time
+=========================
+
+.. attention::
+
+    If you need a time-based UUID, and you don't need the other features
+    included in version 1 UUIDs, we recommend using
+    :ref:`version 7 UUIDs <rfc4122.version7>`.
+
+A version 1 UUID uses a timestamp based on the `Gregorian calendar epoch`_,
+along with the MAC address (or *node*) for a network interface on the local
+machine. This serves two purposes:
+
+1. You can know *when* the identifier was created.
+2. You can know *where* the identifier was created.
+
+In a distributed system, these two pieces of information can be valuable. Not
+only is there no need for a central authority to generate identifiers, but you
+can determine what nodes in your infrastructure created the UUIDs and at what
+time.
+
+.. tip::
+
+    It is also possible to use a **randomly-generated node**, rather than a
+    hardware address. This is useful for when you don't want to leak machine
+    information, while still using a UUID based on time. Keep reading to find
+    out how.
+
+By default, ramsey/uuid will attempt to look up a MAC address for the machine it
+is running on, using this value as the node. If it cannot find a MAC address, it
+will generate a random node.
+
+.. code-block:: php
+    :caption: Generate a version 1, Gregorian time UUID
+    :name: rfc4122.version1.example
+
+    use Ramsey\Uuid\Uuid;
+
+    $uuid = Uuid::uuid1();
+
+    printf(
+        "UUID: %s\nVersion: %d\nDate: %s\nNode: %s\n",
+        $uuid->toString(),
+        $uuid->getFields()->getVersion()?->value,
+        $uuid->getDateTime()->format('r'),
+        $uuid->getFields()->getNode()->toString()
+    );
+
+This will generate a version 1 UUID and print out its string representation, the
+time the UUID was created, and the node used to create the UUID.
+
+It will look something like this:
+
+.. code-block:: text
+
+    UUID: e22e1622-5c14-11ea-b2f3-0242ac130003
+    Version: 1
+    Date: Sun, 01 Mar 2020 23:32:15 +0000
+    Node: 0242ac130003
+
+You may provide custom values for version 1 UUIDs, including node and clock
+sequence.
+
+.. code-block:: php
+    :caption: Provide custom node and clock sequence to create a version 1,
+              Gregorian time UUID
+    :name: rfc4122.version1.custom-example
+
+    use Ramsey\Uuid\Provider\Node\StaticNodeProvider;
+    use Ramsey\Uuid\Type\Hexadecimal;
+    use Ramsey\Uuid\Uuid;
+
+    $nodeProvider = new StaticNodeProvider(new Hexadecimal('121212121212'));
+    $clockSequence = 16383;
+
+    $uuid = Uuid::uuid1($nodeProvider->getNode(), $clockSequence);
+
+.. tip::
+
+    Version 1 UUIDs generated in ramsey/uuid are instances of UuidV1. Check out
+    the :php:class:`Ramsey\\Uuid\\Rfc4122\\UuidV1` API documentation to learn
+    more about what you can do with a UuidV1 instance.
+
+
+.. _rfc4122.version1.custom:
+
+Providing a Custom Node
+#######################
+
+You may override the default behavior by passing your own node value when
+generating a version 1 UUID.
+
+In the :ref:`example above <rfc4122.version1.custom-example>`, we saw how to
+pass a custom node and clock sequence. An interesting thing to note about the
+example is its use of StaticNodeProvider. Why didn't we pass in a
+:php:class:`Hexadecimal <Ramsey\\Uuid\\Type\\Hexadecimal>` value, instead?
+
+According to `RFC 4122, section 4.5`_, node values that do not identify the
+host --- in other words, our own custom node value --- should set the
+unicast/multicast bit to one (1). This bit will never be set in IEEE 802
+addresses obtained from network cards, so it helps to distinguish it from a
+hardware MAC address.
+
+The StaticNodeProvider sets this bit for you. This is why we used it rather
+than providing a :php:class:`Hexadecimal <Ramsey\\Uuid\\Type\\Hexadecimal>`
+value directly.
+
+Recall from the example that the node value we set was ``121212121212``, but if
+you take a look at this value with ``$uuid->getFields()->getNode()->toString()``,
+it becomes:
+
+.. code-block:: text
+
+    131212121212
+
+That's a result of this bit being set by the StaticNodeProvider.
+
+
+.. _rfc4122.version1.random:
+
+Generating a Random Node
+########################
+
+Instead of providing a custom node, you may also generate a random node each
+time you generate a version 1 UUID. The RandomNodeProvider may be used to
+generate a random node value, and like the StaticNodeProvider, it also sets the
+unicast/multicast bit for you.
+
+.. code-block:: php
+    :caption: Provide a random node value to create a version 1, Gregorian time UUID
+    :name: rfc4122.version1.random-example
+
+    use Ramsey\Uuid\Provider\Node\RandomNodeProvider;
+    use Ramsey\Uuid\Uuid;
+
+    $nodeProvider = new RandomNodeProvider();
+
+    $uuid = Uuid::uuid1($nodeProvider->getNode());
+
+
+.. _rfc4122.version1.clock:
+
+What's a Clock Sequence?
+########################
+
+The clock sequence part of a version 1 UUID helps prevent collisions. Since this
+UUID is based on a timestamp and a machine node value, it is possible for
+collisions to occur for multiple UUIDs generated within the same microsecond on
+the same machine.
+
+The clock sequence is the solution to this problem.
+
+The clock sequence is a 14-bit number --- this supports values from 0 to 16,383
+--- which means it should be possible to generate up to 16,384 UUIDs per
+microsecond with the same node value, before hitting a collision.
+
+.. caution::
+
+    ramsey/uuid does not use *stable storage* for clock sequence values.
+    Instead, all clock sequences are randomly-generated. If you are generating
+    a lot of version 1 UUIDs every microsecond, it is possible to hit collisions
+    because of the random values. If this is the case, you should use your own
+    mechanism for generating clock sequence values, to ensure against
+    randomly-generated duplicates.
+
+    See `section 4.2 of RFC 4122`_, for more information.
+
+
+.. _rfc4122.version1.privacy:
+
+Privacy Concerns
+################
+
+As discussed earlier in this section, version 1 UUIDs use a MAC address from a
+local hardware network interface. This means it is possible to uniquely identify
+the machine on which a version 1 UUID was created.
+
+If the value provided by the timestamp of a version 1 UUID is important to you,
+but you do not wish to expose the interface address of any of your local
+machines, see :ref:`rfc4122.version1.random` or :ref:`rfc4122.version1.custom`.
+
+If you do not need an identifier with a timestamp value embedded in it, see
+:ref:`rfc4122.version4` to learn about random UUIDs.
+
+
+.. _Gregorian calendar epoch: https://en.wikipedia.org/wiki/Gregorian_calendar
+.. _RFC 4122: https://tools.ietf.org/html/rfc4122
+.. _RFC 4122, section 4.5: https://tools.ietf.org/html/rfc4122#section-4.5
+.. _section 4.2 of RFC 4122: https://tools.ietf.org/html/rfc4122#section-4.2