create-prisma-php-app 1.0.0

package/vendor/ramsey/uuid/src/UuidInterface.php

@@ -0,0 +1,114 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid;
+
+use JsonSerializable;
+use Ramsey\Uuid\Fields\FieldsInterface;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Integer as IntegerObject;
+use Stringable;
+
+/**
+ * A UUID is a universally unique identifier adhering to an agreed-upon
+ * representation format and standard for generation
+ *
+ * @psalm-immutable
+ */
+interface UuidInterface extends JsonSerializable, Stringable
+{
+    /**
+     * @return mixed[]
+     */
+    public function __serialize(): array;
+
+    /**
+     * Casts the UUID to the string standard representation
+     *
+     * @psalm-return non-empty-string
+     */
+    public function __toString(): string;
+
+    /**
+     * @param mixed[] $data
+     */
+    public function __unserialize(array $data): void;
+
+    /**
+     * Returns -1, 0, or 1 if the UUID is less than, equal to, or greater than
+     * the other UUID
+     *
+     * The first of two UUIDs is greater than the second if the most
+     * significant field in which the UUIDs differ is greater for the first
+     * UUID.
+     *
+     * * Q. What's the value of being able to sort UUIDs?
+     * * A. Use them as keys in a B-Tree or similar mapping.
+     *
+     * @param UuidInterface $other The UUID to compare
+     *
+     * @return int -1, 0, or 1 if the UUID is less than, equal to, or greater than $other
+     */
+    public function compareTo(UuidInterface $other): int;
+
+    /**
+     * Returns true if the UUID is equal to the provided object
+     *
+     * The result is true if and only if the argument is not null, is a UUID
+     * object, has the same variant, and contains the same value, bit-for-bit,
+     * as the UUID.
+     *
+     * @param object|null $other An object to test for equality with this UUID
+     *
+     * @return bool True if the other object is equal to this UUID
+     */
+    public function equals(?object $other): bool;
+
+    /**
+     * Returns the binary string representation of the UUID
+     *
+     * @psalm-return non-empty-string
+     */
+    public function getBytes(): string;
+
+    /**
+     * Returns the fields that comprise this UUID
+     */
+    public function getFields(): FieldsInterface;
+
+    /**
+     * Returns the hexadecimal representation of the UUID
+     */
+    public function getHex(): Hexadecimal;
+
+    /**
+     * Returns the integer representation of the UUID
+     */
+    public function getInteger(): IntegerObject;
+
+    /**
+     * Returns the string standard representation of the UUID as a URN
+     *
+     * @link http://en.wikipedia.org/wiki/Uniform_Resource_Name Uniform Resource Name
+     * @link https://tools.ietf.org/html/rfc4122#section-3 RFC 4122, § 3: Namespace Registration Template
+     */
+    public function getUrn(): string;
+
+    /**
+     * Returns the string standard representation of the UUID
+     *
+     * @psalm-return non-empty-string
+     */
+    public function toString(): string;
+}

package/vendor/ramsey/uuid/src/Validator/GenericValidator.php

@@ -0,0 +1,45 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Validator;
+
+use Ramsey\Uuid\Uuid;
+
+use function preg_match;
+use function str_replace;
+
+/**
+ * GenericValidator validates strings as UUIDs of any variant
+ *
+ * @psalm-immutable
+ */
+final class GenericValidator implements ValidatorInterface
+{
+    /**
+     * Regular expression pattern for matching a UUID of any variant.
+     */
+    private const VALID_PATTERN = '\A[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}\z';
+
+    public function getPattern(): string
+    {
+        return self::VALID_PATTERN;
+    }
+
+    public function validate(string $uuid): bool
+    {
+        $uuid = str_replace(['urn:', 'uuid:', 'URN:', 'UUID:', '{', '}'], '', $uuid);
+
+        return $uuid === Uuid::NIL || preg_match('/' . self::VALID_PATTERN . '/Dms', $uuid);
+    }
+}

package/vendor/ramsey/uuid/src/Validator/ValidatorInterface.php

@@ -0,0 +1,39 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Validator;
+
+/**
+ * A validator validates a string as a proper UUID
+ *
+ * @psalm-immutable
+ */
+interface ValidatorInterface
+{
+    /**
+     * Returns the regular expression pattern used by this validator
+     *
+     * @return non-empty-string The regular expression pattern this validator uses
+     */
+    public function getPattern(): string;
+
+    /**
+     * Returns true if the provided string represents a UUID
+     *
+     * @param string $uuid The string to validate as a UUID
+     *
+     * @return bool True if the string is a valid UUID, false otherwise
+     */
+    public function validate(string $uuid): bool;
+}

package/vendor/ramsey/uuid/src/Variant.php

@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid;
+
+/**
+ * The variant number describes the layout of the UUID
+ *
+ * The variant number has the following meaning:
+ *
+ * - 0 - Reserved for NCS backward compatibility
+ * - 2 - The RFC 4122 variant
+ * - 6 - Reserved, Microsoft Corporation backward compatibility
+ * - 7 - Reserved for future definition
+ *
+ * For RFC 4122 variant UUIDs, this value should always be the integer `2`.
+ *
+ * @link https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.1 RFC 4122, § 4.1.1
+ */
+enum Variant: int
+{
+    /**
+     * Variant: reserved, NCS backward compatibility
+     *
+     * @link https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.1 RFC 4122, § 4.1.1
+     */
+    case ReservedNcs = 0;
+
+    /**
+     * Variant: the UUID layout specified in RFC 4122
+     *
+     * @link https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.1 RFC 4122, § 4.1.1
+     */
+    case Rfc4122 = 2;
+
+    /**
+     * Variant: reserved, Microsoft Corporation backward compatibility
+     *
+     * @link https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.1 RFC 4122, § 4.1.1
+     */
+    case ReservedMicrosoft = 6;
+
+    /**
+     * Variant: reserved for future definition
+     *
+     * @link https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.1 RFC 4122, § 4.1.1
+     */
+    case ReservedFuture = 7;
+}

package/vendor/ramsey/uuid/src/functions.php

@@ -0,0 +1,160 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ * phpcs:disable Squiz.Functions.GlobalFunction
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid;
+
+use DateTimeInterface;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Integer as IntegerObject;
+
+/**
+ * Returns a version 1 (Gregorian time) UUID from a host ID, sequence number,
+ * and the current time
+ *
+ * @param Hexadecimal|positive-int|non-empty-string|null $node A 48-bit number
+ *     representing the hardware address; this number may be represented as an
+ *     integer or a hexadecimal string
+ * @param int<0, 16383>|null $clockSeq A 14-bit number used to help avoid
+ *     duplicates that could arise when the clock is set backwards in time or
+ *     if the node ID changes
+ *
+ * @return non-empty-string Version 1 UUID as a string
+ */
+function v1(Hexadecimal | int | string | null $node = null, ?int $clockSeq = null): string
+{
+    return Uuid::uuid1($node, $clockSeq)->toString();
+}
+
+/**
+ * Returns a version 2 (DCE Security) UUID from a local domain, local
+ * identifier, host ID, clock sequence, and the current time
+ *
+ * @param int $localDomain The local domain to use when generating bytes,
+ *     according to DCE Security
+ * @param IntegerObject|null $localIdentifier The local identifier for the
+ *     given domain; this may be a UID or GID on POSIX systems, if the local
+ *     domain is person or group, or it may be a site-defined identifier
+ *     if the local domain is org
+ * @param Hexadecimal|null $node A 48-bit number representing the hardware
+ *     address
+ * @param int<0, 63>|null $clockSeq A 6-bit number used to help avoid
+ *     duplicates that could arise when the clock is set backwards in time or if
+ *     the node ID changes
+ *
+ * @return non-empty-string Version 2 UUID as a string
+ */
+function v2(
+    int $localDomain,
+    ?IntegerObject $localIdentifier = null,
+    ?Hexadecimal $node = null,
+    ?int $clockSeq = null
+): string {
+    return Uuid::uuid2($localDomain, $localIdentifier, $node, $clockSeq)->toString();
+}
+
+/**
+ * Returns a version 3 (name-based) UUID based on the MD5 hash of a
+ * namespace ID and a name
+ *
+ * @param non-empty-string|UuidInterface $ns The namespace (must be a valid UUID)
+ * @param non-empty-string $name The name to use for creating a UUID
+ *
+ * @return non-empty-string Version 3 UUID as a string
+ *
+ * @psalm-pure note: changing the internal factory is an edge case not covered by purity invariants,
+ *             but under constant factory setups, this method operates in functionally pure manners
+ */
+function v3(UuidInterface | string $ns, string $name): string
+{
+    return Uuid::uuid3($ns, $name)->toString();
+}
+
+/**
+ * Returns a version 4 (random) UUID
+ *
+ * @return non-empty-string Version 4 UUID as a string
+ */
+function v4(): string
+{
+    return Uuid::uuid4()->toString();
+}
+
+/**
+ * Returns a version 5 (name-based) UUID based on the SHA-1 hash of a
+ * namespace ID and a name
+ *
+ * @param non-empty-string|UuidInterface $ns The namespace (must be a valid UUID)
+ * @param non-empty-string $name The name to use for creating a UUID
+ *
+ * @return non-empty-string Version 5 UUID as a string
+ *
+ * @psalm-pure note: changing the internal factory is an edge case not covered by purity invariants,
+ *             but under constant factory setups, this method operates in functionally pure manners
+ */
+function v5(UuidInterface | string $ns, string $name): string
+{
+    return Uuid::uuid5($ns, $name)->toString();
+}
+
+/**
+ * Returns a version 6 (reordered time) UUID from a host ID, sequence number,
+ * and the current time
+ *
+ * @param Hexadecimal|null $node A 48-bit number representing the hardware
+ *     address
+ * @param int<0, 16383>|null $clockSeq A 14-bit number used to help avoid
+ *     duplicates that could arise when the clock is set backwards in time or if
+ *     the node ID changes
+ *
+ * @return non-empty-string Version 6 UUID as a string
+ */
+function v6(?Hexadecimal $node = null, ?int $clockSeq = null): string
+{
+    return Uuid::uuid6($node, $clockSeq)->toString();
+}
+
+/**
+ * Returns a version 7 (Unix Epoch time) UUID
+ *
+ * @param DateTimeInterface|null $dateTime An optional date/time from which
+ *     to create the version 7 UUID. If not provided, the UUID is generated
+ *     using the current date/time.
+ *
+ * @return non-empty-string Version 7 UUID as a string
+ */
+function v7(?DateTimeInterface $dateTime = null): string
+{
+    return Uuid::uuid7($dateTime)->toString();
+}
+
+/**
+ * Returns a version 8 (custom) UUID
+ *
+ * The bytes provided may contain any value according to your application's
+ * needs. Be aware, however, that other applications may not understand the
+ * semantics of the value.
+ *
+ * @param string $bytes A 16-byte octet string. This is an open blob
+ *     of data that you may fill with 128 bits of information. Be aware,
+ *     however, bits 48 through 51 will be replaced with the UUID version
+ *     field, and bits 64 and 65 will be replaced with the UUID variant. You
+ *     MUST NOT rely on these bits for your application needs.
+ *
+ * @return non-empty-string Version 8 UUID as a string
+ */
+function v8(string $bytes): string
+{
+    return Uuid::uuid8($bytes)->toString();
+}