<?xml version="1.0"?>
<doc>
    <assembly>
        <name>PDM.Licensing</name>
    </assembly>
    <members>
        <member name="T:PDM.Licensing.Aws.AwsLicenseTransport">
            <summary>
            <see cref="T:PDM.Licensing.ILicenseTransport"/> backed by the AWS serverless licensing API
            (API Gateway + Lambda + DynamoDB). Sends the license key and machine fingerprint to
            <c>/activate</c> and <c>/validate</c> and returns the server-signed token for the client
            to verify locally. Network and parse failures surface as non-revoking failures so a
            temporary outage never wrongly deactivates a paying customer.
            </summary>
        </member>
        <member name="T:PDM.Licensing.Aws.LicenseRequest">
            <summary>Request body sent to the activate/validate endpoints.</summary>
        </member>
        <member name="T:PDM.Licensing.Aws.TrialRequest">
            <summary>Request body sent to the trial-anchor endpoint.</summary>
        </member>
        <member name="T:PDM.Licensing.Aws.DeactivateRequest">
            <summary>
            Request body sent to the deactivate endpoint. Carries the current signed token so the server can
            authorize the seat release (the token proves the caller is the legitimate holder on this machine).
            </summary>
        </member>
        <member name="T:PDM.Licensing.Aws.LicenseResponse">
            <summary>Response body returned by the activate/validate/trial endpoints.</summary>
        </member>
        <member name="P:PDM.Licensing.Aws.LicenseResponse.TokenExpiresAt">
            <summary>Re-validation deadline for the issued token (at most the server's token TTL).</summary>
        </member>
        <member name="P:PDM.Licensing.Aws.LicenseResponse.SubscriptionExpiresAt">
            <summary>Subscription cutoff; null for a perpetual licence.</summary>
        </member>
        <member name="T:PDM.Licensing.Aws.LicensingConfig">
            <summary>
            Compile-time licensing configuration. The public key is embedded here (not in user-editable
            settings) so it cannot be swapped for an attacker's key without recompiling and defeating
            the obfuscation/anti-tamper measures. Populate these after running the backend deploy:
              - <see cref="F:PDM.Licensing.Aws.LicensingConfig.ApiBaseUrl"/> from the CloudFormation "ApiBaseUrl" output.
              - <see cref="F:PDM.Licensing.Aws.LicensingConfig.PublicKeyBase64"/> from <c>admin/generate-keys.mjs</c> output.
            </summary>
        </member>
        <member name="F:PDM.Licensing.Aws.LicensingConfig.ApiBaseUrl">
            <summary>
            Base URL of the licensing HTTP API. Deployed via backend/licensing/deploy.ps1.
            </summary>
        </member>
        <member name="F:PDM.Licensing.Aws.LicensingConfig.PublicKeyBase64">
            <summary>
            Base64 SubjectPublicKeyInfo of the ECDSA P-256 public key that verifies license tokens.
            The matching private key lives only in AWS SSM (server-side).
            </summary>
        </member>
        <member name="F:PDM.Licensing.Aws.LicensingConfig.PublicKeyHash">
            <summary>
            Pinned SHA-256 (hex) of <see cref="F:PDM.Licensing.Aws.LicensingConfig.PublicKeyBase64"/>. A mismatch at runtime indicates the
            embedded key was swapped (an attacker attempting to sign their own tokens). Regenerate with
            TamperGuard.ComputePublicKeyHash after rotating keys.
            </summary>
        </member>
        <member name="F:PDM.Licensing.Aws.LicensingConfig.LicensingCanaryToken">
            <summary>
            A fixed canary token signed by the licensing <b>private</b> key at key-generation time
            (see <c>admin/generate-canary.mjs</c>). At startup the client verifies this canary with the
            embedded public key: if an attacker swaps the public key for their own (to sign forged
            license tokens), the canary — signed by the real key — stops verifying, so activation is
            disabled. Unlike a self-referential SHA pin (which an attacker recomputes for their own key),
            producing a valid canary requires the server's private key. Empty = not yet configured.
            </summary>
        </member>
        <member name="F:PDM.Licensing.Aws.LicensingConfig.UpdateManifestUrlStable">
            <summary>
            Manifest URL for the stable auto-update channel. The client fetches this on every
            "Check for Updates" and on startup; the manifest is ECDSA-signed with the update key
            below. Set at build time by backend/updates/deploy.ps1.
            </summary>
        </member>
        <member name="F:PDM.Licensing.Aws.LicensingConfig.UpdateManifestUrlBeta">
            <summary>Beta channel manifest URL. Currently the same bucket, different prefix.</summary>
        </member>
        <member name="F:PDM.Licensing.Aws.LicensingConfig.UpdatePublicKeyBase64">
            <summary>
            ECDSA P-256 public key (SubjectPublicKeyInfo, base64) that verifies update manifests.
            Distinct from the licensing key so update signing and license signing can be rotated
            independently. The private half never leaves AWS SSM.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Aws.LicensingConfig.IsConfigured">
            <summary>True when the app was built with a configured licensing backend.</summary>
        </member>
        <member name="P:PDM.Licensing.Aws.LicensingConfig.IsUpdateConfigured">
            <summary>True when auto-update is configured (manifest URL + update public key both set).</summary>
        </member>
        <member name="T:PDM.Licensing.DpapiLicenseStore">
            <summary>
            Persists the <see cref="T:PDM.Licensing.LicenseRecord"/> to disk, encrypted with Windows DPAPI at
            the current-user scope. This prevents casual tampering with the trial-start
            timestamp and hides the raw license key from disk snooping. Reads are transparent
            to callers; a corrupt or unreadable file yields null so the app treats it as first
            launch and starts a fresh trial rather than crashing.
            </summary>
        </member>
        <member name="M:PDM.Licensing.DpapiLicenseStore.LoadAsync(System.Threading.CancellationToken)">
            <inheritdoc />
        </member>
        <member name="M:PDM.Licensing.DpapiLicenseStore.SaveAsync(PDM.Licensing.LicenseRecord,System.Threading.CancellationToken)">
            <inheritdoc />
        </member>
        <member name="T:PDM.Licensing.ILicenseStore">
            <summary>Loads and persists the local <see cref="T:PDM.Licensing.LicenseRecord"/>.</summary>
        </member>
        <member name="M:PDM.Licensing.ILicenseStore.LoadAsync(System.Threading.CancellationToken)">
            <summary>Returns the persisted record, or null if none exists.</summary>
        </member>
        <member name="M:PDM.Licensing.ILicenseStore.SaveAsync(PDM.Licensing.LicenseRecord,System.Threading.CancellationToken)">
            <summary>Overwrites the persisted record.</summary>
        </member>
        <member name="T:PDM.Licensing.LicenseValidationResult">
            <summary>
            Represents the outcome of an online activation or validation call.
            </summary>
        </member>
        <member name="P:PDM.Licensing.LicenseValidationResult.IsValid">
            <summary>True when the server accepted the key for this fingerprint.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseValidationResult.ExpiresUtc">
            <summary>UTC expiry reported by the server, if any (subscription models).</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseValidationResult.Owner">
            <summary>Human-friendly owner/account name.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseValidationResult.Message">
            <summary>Human-readable message for the UI when <see cref="P:PDM.Licensing.LicenseValidationResult.IsValid"/> is false.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseValidationResult.Token">
            <summary>
            The server-signed license token (base64url payload + signature). This is the
            authoritative entitlement; the client stores it and verifies its signature locally.
            </summary>
        </member>
        <member name="P:PDM.Licensing.LicenseValidationResult.Features">
            <summary>Feature flags granted by the license, as reported by the server.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseValidationResult.Revoked">
            <summary>True when the server explicitly reported the license as revoked/suspended.</summary>
        </member>
        <member name="T:PDM.Licensing.ILicenseTransport">
            <summary>
            Talks to a license-issuing service (e.g. keygen.sh) to validate and activate a
            license key against the current machine fingerprint. Implementations must be
            safe to call from a UI thread (async, no blocking network I/O).
            </summary>
        </member>
        <member name="M:PDM.Licensing.ILicenseTransport.ActivateAsync(System.String,System.String,System.Threading.CancellationToken)">
            <summary>
            Activates <paramref name="licenseKey"/> for the given <paramref name="fingerprint"/>.
            A successful result may return an expiry (subscription) or no expiry (perpetual).
            </summary>
        </member>
        <member name="M:PDM.Licensing.ILicenseTransport.ValidateAsync(System.String,System.String,System.Threading.CancellationToken)">
            <summary>
            Re-validates a previously activated license. Called periodically so a revoked or
            moved-machine license eventually flips to invalid without requiring the user to
            re-enter the key.
            </summary>
        </member>
        <member name="M:PDM.Licensing.ILicenseTransport.GetTrialAnchorAsync(System.String,System.Threading.CancellationToken)">
            <summary>
            Fetches the server-signed trial anchor for this machine. The server remembers the first
            time each fingerprint was seen, so the returned token carries the original trial start
            even after a reinstall — this is what prevents trial resets. Returns a token string, or
            null on failure (offline: the client falls back to a local trial start).
            </summary>
        </member>
        <member name="M:PDM.Licensing.ILicenseTransport.DeactivateAsync(System.String,System.String,System.String,System.Threading.CancellationToken)">
            <summary>
            Releases this machine's activation seat on the server so the license can be moved to another
            PC. Must present the current server-signed <paramref name="token"/>: the server authorizes
            the release only when the token's signature is valid and its claims match this key + machine,
            which prevents a third party who merely knows a key + fingerprint from griefing the seat.
            Best-effort and idempotent: returns <see langword="true"/> when the server confirmed the
            release (or there was nothing to release), and <see langword="false"/> when it could not be
            reached or refused. Must not throw for ordinary network failures so local deactivation can
            still proceed.
            </summary>
        </member>
        <member name="T:PDM.Licensing.NullLicenseTransport">
            <summary>
            Offline-only transport that always fails. Used when the server URL is unset and
            as the default so the app runs without configuring an issuer. Real deployments
            configure a keygen.sh transport in its place.
            </summary>
        </member>
        <member name="T:PDM.Licensing.InMemoryLicenseStore">
            <summary>Volatile <see cref="T:PDM.Licensing.ILicenseStore"/> used by tests.</summary>
        </member>
        <member name="T:PDM.Licensing.LicenseRecord">
            <summary>
            Persistent licensing state stored on the local machine. Written encrypted (DPAPI) so
            the trial-start timestamp and activation details cannot be trivially tampered with.
            </summary>
        </member>
        <member name="P:PDM.Licensing.LicenseRecord.FirstLaunchUtc">
            <summary>UTC timestamp when the app was first launched on this machine.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseRecord.MaxSeenUtc">
            <summary>
            Highest UTC time ever observed by the app (monotonic anti-rollback watermark). Trial and
            token expiry are evaluated against <c>max(systemClock, MaxSeenUtc)</c>, so winding the
            system clock backwards cannot extend a trial or keep an expired token alive.
            </summary>
        </member>
        <member name="P:PDM.Licensing.LicenseRecord.LicenseKey">
            <summary>The activation key the user entered, or null when running unlicensed.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseRecord.BoundFingerprint">
            <summary>Machine fingerprint the license was activated against; used for tamper detection.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseRecord.LastValidatedUtc">
            <summary>UTC timestamp of the last successful server validation.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseRecord.ExpiresUtc">
            <summary>
            UTC expiry reported by the server (subscription cutoff), if any. Null means either
            unlicensed or a perpetual licence — check <see cref="P:PDM.Licensing.LicenseRecord.SignedToken"/> to tell them apart.
            This is the customer-facing end date, NOT the token's re-validation deadline.
            </summary>
        </member>
        <member name="P:PDM.Licensing.LicenseRecord.TokenExpiresUtc">
            <summary>
            UTC expiry of the currently stored <see cref="P:PDM.Licensing.LicenseRecord.SignedToken"/> — the offline re-validation
            deadline (at most the server's token TTL away). Kept separate from
            <see cref="P:PDM.Licensing.LicenseRecord.ExpiresUtc"/> so a short token lifetime is never mistaken for the licence
            running out.
            </summary>
        </member>
        <member name="P:PDM.Licensing.LicenseRecord.Owner">
            <summary>Human-friendly account name returned by the server, if any.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseRecord.SignedToken">
            <summary>The server-signed license token; the authoritative entitlement, verified locally.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseRecord.Features">
            <summary>Feature flags granted by the license.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseRecord.TrialToken">
            <summary>
            Server-signed trial anchor for this machine. When present and valid, its start date
            (not the local <see cref="P:PDM.Licensing.LicenseRecord.FirstLaunchUtc"/>) governs the trial, so reinstalling cannot
            reset it.
            </summary>
        </member>
        <member name="T:PDM.Licensing.LicenseEntitlements">
             <summary>
             Resolved, ready-to-apply capability limits for the current licensing state. These are derived
             from the <b>signed</b> token claims (for activated/grace licenses) or from fixed tier defaults
             (trial / expired), never from a single boolean. A <see langword="null"/> cap means "no
             client-imposed limit" (full speed).
            
             <para>Security intent (C1): the premium throughput numbers ride inside a server-signed token, so
             forcing a status flag on a patched client cannot fabricate them. Callers apply these caps at the
             point of use rather than reading one central "is licensed" bool.</para>
             </summary>
        </member>
        <member name="M:PDM.Licensing.LicenseEntitlements.#ctor(System.Nullable{System.Int32},System.Nullable{System.Int32},System.String[])">
             <summary>
             Resolved, ready-to-apply capability limits for the current licensing state. These are derived
             from the <b>signed</b> token claims (for activated/grace licenses) or from fixed tier defaults
             (trial / expired), never from a single boolean. A <see langword="null"/> cap means "no
             client-imposed limit" (full speed).
            
             <para>Security intent (C1): the premium throughput numbers ride inside a server-signed token, so
             forcing a status flag on a patched client cannot fabricate them. Callers apply these caps at the
             point of use rather than reading one central "is licensed" bool.</para>
             </summary>
        </member>
        <member name="F:PDM.Licensing.LicenseEntitlements.Free">
            <summary>Reduced free/expired tier: throttled, one-at-a-time.</summary>
        </member>
        <member name="F:PDM.Licensing.LicenseEntitlements.Full">
            <summary>Full trial/licensed tier when no explicit signed cap is present: uncapped.</summary>
        </member>
        <member name="T:PDM.Licensing.LicenseSnapshot">
            <summary>
            Immutable, coarse view of the current licensing state used by the UI.
            </summary>
        </member>
        <member name="M:PDM.Licensing.LicenseSnapshot.#ctor(PDM.Licensing.LicenseStatus,System.TimeSpan,System.String,System.String,PDM.Licensing.LicenseEntitlements)">
            <summary>
            Immutable, coarse view of the current licensing state used by the UI.
            </summary>
        </member>
        <member name="P:PDM.Licensing.LicenseSnapshot.IsFunctional">
            <summary>True when the app should offer full commercial features.</summary>
        </member>
        <member name="T:PDM.Licensing.LicenseService">
             <summary>
             Coordinates trial timing, license activation, periodic re-validation, and hardware binding.
            
             Security model: activation and activated-state are anchored on a <b>server-signed token</b>
             verified locally with an embedded public key (<see cref="T:PDM.Licensing.Signed.LicenseTokenVerifier"/>). The client
             never decides "licensed = true" from a plain server response; it requires a cryptographically
             signed token whose claims (license key, machine fingerprint, expiry) it re-checks on every
             launch. An attacker cannot forge such a token without the server's private key, and a patched
             transport that "returns success" produces no token, so it cannot unlock the product.
            
             Tokens are short-lived (server TTL). The client tolerates brief offline periods up to the
             token expiry plus a grace window; beyond that it must re-validate online.
             </summary>
        </member>
        <member name="F:PDM.Licensing.LicenseService.DefaultTrialLength">
            <summary>Length of the initial free trial (14 days).</summary>
        </member>
        <member name="F:PDM.Licensing.LicenseService.DefaultGracePeriod">
            <summary>Grace period after the trial or token expires before features lock.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseService.TrialLength">
            <summary>Trial length; overridable for testing.</summary>
        </member>
        <member name="P:PDM.Licensing.LicenseService.GracePeriod">
            <summary>Grace period; overridable for testing.</summary>
        </member>
        <member name="M:PDM.Licensing.LicenseService.GetSnapshotAsync(System.Threading.CancellationToken)">
            <summary>Loads the current snapshot, creating a fresh trial record on first launch.</summary>
        </member>
        <member name="M:PDM.Licensing.LicenseService.AdvanceMonotonicClockAsync(PDM.Licensing.LicenseRecord,System.Threading.CancellationToken)">
            <summary>
            Advances the persisted anti-rollback watermark (H3) when the real clock is ahead of it, so
            the highest-ever-seen time is durable. A single small write only when the clock moves
            forward — no cost on the download hot path.
            </summary>
        </member>
        <member name="M:PDM.Licensing.LicenseService.EffectiveNow(PDM.Licensing.LicenseRecord)">
            <summary>
            The trustworthy "now" for expiry math: the later of the system clock and the persisted
            watermark. Winding the clock back therefore cannot roll time backwards for licensing.
            </summary>
        </member>
        <member name="M:PDM.Licensing.LicenseService.EnsureTrialAnchorAsync(System.Threading.CancellationToken)">
            <summary>
            Fetches the server-signed trial anchor for this machine and stores it, so the trial start
            is authoritative and survives reinstalls. No-op when a license is already active or the
            server is unreachable (the client then falls back to its local trial start).
            Call once at startup after <see cref="M:PDM.Licensing.LicenseService.GetSnapshotAsync(System.Threading.CancellationToken)"/>.
            </summary>
        </member>
        <member name="M:PDM.Licensing.LicenseService.ActivateAsync(System.String,System.Threading.CancellationToken)">
            <summary>
            Activates <paramref name="licenseKey"/>. Requires the server to return a signed token
            that verifies locally and is bound to this machine; otherwise activation is refused.
            </summary>
        </member>
        <member name="M:PDM.Licensing.LicenseService.RefreshAsync(System.Threading.CancellationToken)">
            <summary>
            Re-validates the current license and refreshes its token. A transient failure keeps the
            existing token (offline tolerance up to its expiry + grace); an explicit revocation clears it.
            </summary>
        </member>
        <member name="M:PDM.Licensing.LicenseService.DeactivateAsync(System.Threading.CancellationToken)">
            <summary>
            Deactivates the license on this PC. Releases the machine's activation seat on the server
            (best-effort) so the license can be re-activated on another computer, then clears the local
            record regardless. Clearing only local state — the previous behaviour — left the seat bound
            server-side, so the admin panel still showed the machine and the activation slot stayed
            consumed, blocking the user from moving the license.
            </summary>
        </member>
        <member name="M:PDM.Licensing.LicenseService.EntitlementsFromClaims(PDM.Licensing.Signed.LicenseClaims)">
            <summary>
            Resolves the ready-to-apply caps from verified license claims. A signed value &lt;= 0 means
            "no client-imposed cap" (full speed); a positive value is the enforced limit.
            </summary>
        </member>
        <member name="M:PDM.Licensing.LicenseService.ResolveTrialWindow(PDM.Licensing.LicenseRecord)">
            <summary>
            Determines the effective trial start and length. Uses the verified server anchor when
            present; otherwise the local first-launch time. The anchor cannot be forged (signed) and
            its start is server-authoritative per machine fingerprint.
            </summary>
        </member>
        <member name="M:PDM.Licensing.LicenseService.ResolveLicensedRemaining(PDM.Licensing.Signed.LicenseClaims,System.DateTimeOffset)">
             <summary>
             How long the <b>licence</b> still has to run, for display purposes.
            
             <para>Payload v3+ carries <see cref="P:PDM.Licensing.Signed.LicenseClaims.SubscriptionExpiresAt"/>: a value means a
             dated subscription, and null means perpetual (reported as <see cref="F:System.TimeSpan.MaxValue"/>,
             which the UI renders as "Perpetual license").</para>
            
             <para>Pre-v3 tokens carry only the token expiry, so there is nothing better to show; those
             keep the historical behaviour and self-correct on the next successful re-validation, which
             returns a v3 token.</para>
             </summary>
        </member>
        <member name="T:PDM.Licensing.LicenseStatus">
            <summary>Coarse licensing state for the running application.</summary>
        </member>
        <member name="F:PDM.Licensing.LicenseStatus.Trial">
            <summary>The trial period is still active; the app is fully functional.</summary>
        </member>
        <member name="F:PDM.Licensing.LicenseStatus.Grace">
            <summary>The trial expired but a short grace period is still in effect.</summary>
        </member>
        <member name="F:PDM.Licensing.LicenseStatus.Expired">
            <summary>Trial and grace period have both expired; features that require a license should be locked.</summary>
        </member>
        <member name="F:PDM.Licensing.LicenseStatus.Activated">
            <summary>A valid, activated license is present.</summary>
        </member>
        <member name="F:PDM.Licensing.LicenseStatus.Invalid">
            <summary>A license exists but validation failed (e.g. revoked or moved to another device).</summary>
        </member>
        <member name="T:PDM.Licensing.MachineFingerprint">
             <summary>
             Produces a stable, per-machine identifier used to bind license activations.
            
             <para><b>Composition (hardening H1).</b> The fingerprint is anchored primarily on the
             <b>SMBIOS system UUID</b> read directly from firmware via <c>GetSystemFirmwareTable</c>. Unlike
             the registry <c>MachineGuid</c> (a regkey an attacker can edit) or the system volume serial
             (reset by a reformat / spoofed by tooling), the firmware UUID is baked into the board and is not
             user-editable on real hardware, so it resists both spoofing and trial-farming. The machine GUID
             is folded in as a secondary source for extra entropy and to distinguish VMs that share a
             firmware UUID. Everything is SHA-256'd, so the raw identifiers never appear on disk or on the
             wire, and the output is a fixed 64-char hex string that satisfies the server's fingerprint
             contract.</para>
            
             <para>The value is computed once and cached for the process lifetime — the firmware read is a
             single fast syscall, but caching keeps activation/validation off any repeated cost.</para>
             </summary>
        </member>
        <member name="M:PDM.Licensing.MachineFingerprint.Compute">
            <summary>
            Returns the SHA-256 hex fingerprint for the current machine. Falls back to a
            process-specific value on non-Windows or when the required Windows identifiers cannot be
            read; the fallback ensures the app is still usable in development scenarios.
            </summary>
        </member>
        <member name="M:PDM.Licensing.MachineFingerprint.ReadSmbiosSystemUuid">
            <summary>
            Reads the SMBIOS Type 1 (System Information) structure's UUID directly from firmware. Returns
            a hex string, or null when the table is unavailable or the UUID is an "unset" sentinel
            (all-zero / all-0xFF), which some OEMs and VMs report.
            </summary>
        </member>
        <member name="T:PDM.Licensing.Security.TamperGuard">
             <summary>
             Runtime integrity and debugger-presence checks that raise the cost of tampering. These are
             deterrents, not guarantees: a determined attacker with a native debugger and time can defeat
             any client-side check. Their purpose is to stop casual patching and automated cracking.
            
             The most important protection is elsewhere — license entitlements ride on a server-signed
             token verified by an embedded public key, so forging a license requires the server's private
             key regardless of what the client binary is patched to believe.
             </summary>
        </member>
        <member name="M:PDM.Licensing.Security.TamperGuard.IsDebuggerPresent">
            <summary>
            Returns true when a managed or native debugger appears to be attached. Callers may use
            this to add friction (e.g. extra server round-trips) rather than as a hard gate, to avoid
            penalising legitimate power users.
            </summary>
        </member>
        <member name="M:PDM.Licensing.Security.TamperGuard.ComputePublicKeyHash(System.String)">
            <summary>
            Computes the SHA-256 of the embedded licensing public key. The app pins the expected
            value; a mismatch means the key was swapped (an attacker trying to sign their own tokens),
            which callers should treat as tampering.
            </summary>
        </member>
        <member name="M:PDM.Licensing.Security.TamperGuard.VerifyPublicKeyIntegrity(System.String,System.String)">
            <summary>
            Verifies the embedded public key matches the pinned hash. Returns true when intact.
            </summary>
        </member>
        <member name="T:PDM.Licensing.Security.TamperGuard.SelfIntegrity">
            <summary>Outcome of an Authenticode self-integrity check.</summary>
        </member>
        <member name="F:PDM.Licensing.Security.TamperGuard.SelfIntegrity.Trusted">
            <summary>The file has a valid, trusted Authenticode signature (untampered).</summary>
        </member>
        <member name="F:PDM.Licensing.Security.TamperGuard.SelfIntegrity.Tampered">
            <summary>The file is signed but the signature is invalid — a definite tamper signal.</summary>
        </member>
        <member name="F:PDM.Licensing.Security.TamperGuard.SelfIntegrity.Unsigned">
            <summary>The file is not signed (dev/unsigned build); inconclusive, do not punish.</summary>
        </member>
        <member name="M:PDM.Licensing.Security.TamperGuard.VerifySelfIntegrity(System.String)">
             <summary>
             Verifies the Authenticode signature of the given file (defaults to the running executable)
             via <c>WinVerifyTrust</c>. This is the real anti-tamper anchor (C2/C3): once the shipping
             binary is code-signed, ANY modification — including swapping the embedded licensing public
             key — invalidates the signature and returns <see cref="F:PDM.Licensing.Security.TamperGuard.SelfIntegrity.Tampered"/>. An unsigned
             (developer) build returns <see cref="F:PDM.Licensing.Security.TamperGuard.SelfIntegrity.Unsigned"/> so it is never punished.
            
             <para>Cheap and safe to call off the startup path: a single native call, no allocation on the
             hot path, no exceptions escape.</para>
             </summary>
        </member>
        <member name="T:PDM.Licensing.Serialization.PdmLicensingJsonContext">
             <summary>
             System.Text.Json source-generation context for the licensing types: the locally persisted
             <see cref="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.LicenseRecord"/>, the signed <see cref="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.LicenseClaims"/> / <see cref="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.TrialClaims"/>,
             and the AWS transport request/response bodies. Compile-time metadata keeps the licensing crypto
             path free of runtime reflection so it works under NativeAOT/trimming.
            
             <para>Null properties are omitted on write (matching the previous DPAPI store behaviour); property
             names come from each type's <c>[JsonPropertyName]</c> attributes, so no naming policy is needed.</para>
             </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.Boolean">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.DeactivateRequest">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.LicenseRequest">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.LicenseResponse">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.TrialRequest">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.LicenseRecord">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.LicenseClaims">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.TrialClaims">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.DateTimeOffset">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.NullableDateTimeOffset">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.Int32">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.String">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.StringArray">
            <summary>
            Defines the source generated JSON serialization contract metadata for a given type.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.Default">
            <summary>
            The default <see cref="T:System.Text.Json.Serialization.JsonSerializerContext"/> associated with a default <see cref="T:System.Text.Json.JsonSerializerOptions"/> instance.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Serialization.PdmLicensingJsonContext.GeneratedSerializerOptions">
            <summary>
            The source-generated options associated with this context.
            </summary>
        </member>
        <member name="M:PDM.Licensing.Serialization.PdmLicensingJsonContext.#ctor">
            <inheritdoc/>
        </member>
        <member name="M:PDM.Licensing.Serialization.PdmLicensingJsonContext.#ctor(System.Text.Json.JsonSerializerOptions)">
            <inheritdoc/>
        </member>
        <member name="M:PDM.Licensing.Serialization.PdmLicensingJsonContext.GetTypeInfo(System.Type)">
            <inheritdoc/>
        </member>
        <member name="T:PDM.Licensing.Signed.Base64Url">
            <summary>Minimal base64url (RFC 4648 §5) encode/decode without external dependencies.</summary>
        </member>
        <member name="T:PDM.Licensing.Signed.LicenseClaims">
            <summary>
            The claims carried inside a server-signed license token. These are authoritative only
            after the token's signature has been verified against the embedded public key.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Signed.LicenseClaims.MaxConnections">
            <summary>
            Signed per-download connection cap. A value &lt;= 0 means "no client-imposed cap" (full
            speed) for this licensed install. The client derives its actual connection limit from this
            number rather than from a local boolean, so the premium throughput value exists only inside
            a token this server signed — patching a flag cannot conjure it.
            </summary>
        </member>
        <member name="P:PDM.Licensing.Signed.LicenseClaims.MaxParallel">
            <summary>Signed simultaneous-download cap. A value &lt;= 0 means "no client-imposed cap".</summary>
        </member>
        <member name="P:PDM.Licensing.Signed.LicenseClaims.ExpiresAt">
            <summary>
            When this <b>token</b> stops being accepted offline — the re-validation deadline, at most
            the server's token TTL away (currently 14 days). This is deliberately short so revocation
            takes effect promptly; it is <b>not</b> the customer's subscription end date and must never
            be shown as "time left on your licence".
            </summary>
        </member>
        <member name="P:PDM.Licensing.Signed.LicenseClaims.SubscriptionExpiresAt">
            <summary>
            When the customer's entitlement actually ends. <see langword="null"/> means a perpetual
            licence. Present from payload <see cref="P:PDM.Licensing.Signed.LicenseClaims.Version"/> 3 onwards; older tokens carry only
            <see cref="P:PDM.Licensing.Signed.LicenseClaims.ExpiresAt"/>, so treat null-on-v2 as "unknown" rather than perpetual.
            </summary>
        </member>
        <member name="T:PDM.Licensing.Signed.LicenseTokenVerifier">
             <summary>
             Verifies server-issued license tokens. A token is <c>base64url(payloadJson).base64url(signature)</c>
             where the signature is ECDSA P-256 (SHA-256, DER) over the raw payload bytes. Only the
             public key is embedded in the client; the private key never leaves the server, so a
             tampered or self-minted token cannot pass verification.
            
             This is the anti-forgery backbone of the licensing system: because entitlement decisions
             derive from a signed token rather than a local boolean, an attacker cannot "activate" the
             product by editing configuration or returning a fake success from a patched transport —
             they would still need the server's private key to produce a token the client accepts.
             </summary>
        </member>
        <member name="M:PDM.Licensing.Signed.LicenseTokenVerifier.Verify(System.String)">
            <summary>
            Verifies the token's signature and, on success, returns its parsed license claims.
            Returns null when the token is malformed or the signature does not match.
            Does NOT evaluate expiry or fingerprint — callers apply those policy checks.
            </summary>
        </member>
        <member name="M:PDM.Licensing.Signed.LicenseTokenVerifier.VerifyPayload(System.String)">
            <summary>
            Verifies the token's signature and returns the raw payload bytes on success, or null.
            Callers deserialize into whichever claims shape the token carries (license or trial).
            </summary>
        </member>
        <member name="M:PDM.Licensing.Signed.LicenseTokenVerifier.VerifyTrial(System.String)">
            <summary>Verifies a signed trial anchor token and returns its claims, or null.</summary>
        </member>
        <member name="T:PDM.Licensing.Signed.TrialClaims">
            <summary>
            Claims inside a server-signed trial anchor. Authoritative only after signature verification.
            The server records the first-seen time per machine fingerprint, so this <see cref="P:PDM.Licensing.Signed.TrialClaims.TrialStartUtc"/>
            survives reinstalls and local-file/registry tampering — defeating trial resets.
            </summary>
        </member>
    </members>
</doc>
