create-prisma-php-app 1.0.0 → 1.0.1

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

@@ -1,102 +0,0 @@
-.. _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

@@ -1,60 +0,0 @@
-.. _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

@@ -1,34 +0,0 @@
-.. _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

@@ -1,32 +0,0 @@
-.. _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

@@ -1,37 +0,0 @@
-.. _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

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

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

@@ -1,192 +0,0 @@
-.. _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