< Summary

Information
Class: AsiBackbone.Core.Outbox.GovernanceOutboxEntry
Assembly: AsiBackbone.Core
File(s): /home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.Core/Outbox/GovernanceOutboxEntry.cs
Line coverage
100%
Covered lines: 249
Uncovered lines: 0
Coverable lines: 249
Total lines: 584
Line coverage: 100%
Branch coverage
92%
Covered branches: 87
Total branches: 94
Branch coverage: 92.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
.ctor(...)100%1414100%
get_IsDelivered()100%11100%
get_IsDeadLettered()100%11100%
get_HasMetadata()100%11100%
get_HasClaim()100%66100%
Create(...)100%22100%
Restore(...)100%11100%
IsRetryReady(...)93.75%1616100%
HasActiveClaim(...)75%44100%
CanBeClaimed(...)50%44100%
IsClaimedBy(...)100%44100%
MarkClaimed(...)87.5%88100%
ReleaseClaim(...)100%11100%
MarkDelivered(...)100%22100%
MarkFailed(...)100%22100%
MarkDeferred(...)100%22100%
MarkDeadLettered(...)100%22100%
Copy(...)100%22100%
NormalizeIdentifier(...)100%22100%
NormalizeOptional(...)100%22100%
MergeMetadata(...)100%88100%
NormalizeMetadata(...)85.71%1414100%

File(s)

/home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.Core/Outbox/GovernanceOutboxEntry.cs

#LineLine coverage
 1using System.Collections.ObjectModel;
 2using AsiBackbone.Core.Emissions;
 3
 4namespace AsiBackbone.Core.Outbox;
 5
 6/// <summary>
 7/// Represents a provider-neutral durable outbox entry for a governance emission envelope.
 8/// </summary>
 9/// <remarks>
 10/// Outbox entries are intended to be persisted before optional downstream provider delivery is attempted.
 11/// </remarks>
 12public sealed class GovernanceOutboxEntry
 13{
 14    private const int DefaultMaxRetryCount = 5;
 15
 316    private static readonly IReadOnlyDictionary<string, string> EmptyMetadata =
 317        new ReadOnlyDictionary<string, string>(
 318            new Dictionary<string, string>(StringComparer.Ordinal));
 19
 113320    private GovernanceOutboxEntry(
 113321        string outboxEntryId,
 113322        GovernanceEmissionEnvelope envelope,
 113323        GovernanceEmissionStatus status,
 113324        DateTimeOffset createdUtc,
 113325        DateTimeOffset updatedUtc,
 113326        int retryCount,
 113327        int maxRetryCount,
 113328        DateTimeOffset? nextRetryUtc,
 113329        GovernanceEmissionError? lastError,
 113330        string? providerName,
 113331        string? providerRecordId,
 113332        string? deadLetterReason,
 113333        IReadOnlyDictionary<string, string> metadata,
 113334        string? claimOwner,
 113335        string? claimToken,
 113336        DateTimeOffset? claimedUtc,
 113337        DateTimeOffset? claimExpiresUtc,
 113338        int claimAttemptCount)
 39    {
 113340        ArgumentException.ThrowIfNullOrWhiteSpace(outboxEntryId);
 113141        ArgumentNullException.ThrowIfNull(envelope);
 42
 113043        if (!Enum.IsDefined(status))
 44        {
 245            throw new ArgumentOutOfRangeException(nameof(status), status, "Outbox status must be defined.");
 46        }
 47
 112848        if (retryCount < 0)
 49        {
 250            throw new ArgumentOutOfRangeException(nameof(retryCount), retryCount, "Retry count must be greater than or e
 51        }
 52
 112653        if (maxRetryCount < 0)
 54        {
 355            throw new ArgumentOutOfRangeException(nameof(maxRetryCount), maxRetryCount, "Maximum retry count must be gre
 56        }
 57
 112358        if (claimAttemptCount < 0)
 59        {
 160            throw new ArgumentOutOfRangeException(nameof(claimAttemptCount), claimAttemptCount, "Claim attempt count mus
 61        }
 62
 112263        OutboxEntryId = outboxEntryId.Trim();
 112264        Envelope = envelope;
 112265        Status = status;
 112266        CreatedUtc = createdUtc.ToUniversalTime();
 112267        UpdatedUtc = updatedUtc.ToUniversalTime();
 112268        RetryCount = retryCount;
 112269        MaxRetryCount = maxRetryCount;
 112270        NextRetryUtc = nextRetryUtc?.ToUniversalTime();
 112271        LastError = lastError;
 112272        ProviderName = NormalizeOptional(providerName);
 112273        ProviderRecordId = NormalizeOptional(providerRecordId);
 112274        DeadLetterReason = NormalizeOptional(deadLetterReason);
 112275        Metadata = metadata;
 112276        ClaimOwner = NormalizeOptional(claimOwner);
 112277        ClaimToken = NormalizeOptional(claimToken);
 112278        ClaimedUtc = claimedUtc?.ToUniversalTime();
 112279        ClaimExpiresUtc = claimExpiresUtc?.ToUniversalTime();
 112280        ClaimAttemptCount = claimAttemptCount;
 112281    }
 82
 83    /// <summary>
 84    /// Gets the stable outbox entry identifier.
 85    /// </summary>
 86    public string OutboxEntryId { get; }
 87
 88    /// <summary>
 89    /// Gets the provider-neutral governance emission envelope being persisted for delivery.
 90    /// </summary>
 91    public GovernanceEmissionEnvelope Envelope { get; }
 92
 93    /// <summary>
 94    /// Gets the current provider-neutral outbox status.
 95    /// </summary>
 96    public GovernanceEmissionStatus Status { get; }
 97
 98    /// <summary>
 99    /// Gets the UTC timestamp when the outbox entry was created.
 100    /// </summary>
 101    public DateTimeOffset CreatedUtc { get; }
 102
 103    /// <summary>
 104    /// Gets the UTC timestamp when the outbox entry was last updated.
 105    /// </summary>
 106    public DateTimeOffset UpdatedUtc { get; }
 107
 108    /// <summary>
 109    /// Gets the number of failed or deferred delivery attempts recorded for this entry.
 110    /// </summary>
 111    public int RetryCount { get; }
 112
 113    /// <summary>
 114    /// Gets the persisted maximum retry count retained for storage compatibility.
 115    /// </summary>
 116    /// <remarks>
 117    /// Retry eligibility and threshold dead-lettering are controlled by <see cref="GovernanceOutboxOptions" />
 118    /// when the entry is processed by <see cref="GovernanceOutboxDrain" />.
 119    /// </remarks>
 120    public int MaxRetryCount { get; }
 121
 122    /// <summary>
 123    /// Gets the next UTC retry timestamp, when retry scheduling is active.
 124    /// </summary>
 125    public DateTimeOffset? NextRetryUtc { get; }
 126
 127    /// <summary>
 128    /// Gets the last provider-neutral emission error, when available.
 129    /// </summary>
 130    public GovernanceEmissionError? LastError { get; }
 131
 132    /// <summary>
 133    /// Gets the provider name associated with the most recent attempt, when available.
 134    /// </summary>
 135    public string? ProviderName { get; }
 136
 137    /// <summary>
 138    /// Gets the provider-side record identifier, when delivery returned one and it is safe to store.
 139    /// </summary>
 140    public string? ProviderRecordId { get; }
 141
 142    /// <summary>
 143    /// Gets the dead-letter reason, when the entry has reached a terminal dead-letter state.
 144    /// </summary>
 145    public string? DeadLetterReason { get; }
 146
 147    /// <summary>
 148    /// Gets minimized provider-neutral outbox metadata.
 149    /// </summary>
 150    public IReadOnlyDictionary<string, string> Metadata { get; }
 151
 152    /// <summary>
 153    /// Gets the current claim owner, when this row is leased by a worker.
 154    /// </summary>
 155    public string? ClaimOwner { get; }
 156
 157    /// <summary>
 158    /// Gets the opaque token for the current claim lease.
 159    /// </summary>
 160    public string? ClaimToken { get; }
 161
 162    /// <summary>
 163    /// Gets the UTC timestamp when the current claim was acquired.
 164    /// </summary>
 165    public DateTimeOffset? ClaimedUtc { get; }
 166
 167    /// <summary>
 168    /// Gets the UTC timestamp when the current claim lease expires.
 169    /// </summary>
 170    public DateTimeOffset? ClaimExpiresUtc { get; }
 171
 172    /// <summary>
 173    /// Gets the number of claim or reclaim attempts recorded for this entry.
 174    /// </summary>
 175    public int ClaimAttemptCount { get; }
 176
 177    /// <summary>
 178    /// Gets a value indicating whether this entry was delivered successfully.
 179    /// </summary>
 419180    public bool IsDelivered => Status is GovernanceEmissionStatus.Delivered;
 181
 182    /// <summary>
 183    /// Gets a value indicating whether this entry has reached a terminal dead-letter state.
 184    /// </summary>
 398185    public bool IsDeadLettered => Status is GovernanceEmissionStatus.DeadLettered;
 186
 187    /// <summary>
 188    /// Gets a value indicating whether metadata is present.
 189    /// </summary>
 38190    public bool HasMetadata => Metadata.Count > 0;
 191
 192    /// <summary>
 193    /// Gets a value indicating whether claim metadata is present.
 194    /// </summary>
 164195    public bool HasClaim => ClaimOwner is not null && ClaimToken is not null && ClaimedUtc.HasValue && ClaimExpiresUtc.H
 196
 197    /// <summary>
 198    /// Creates a pending durable outbox entry.
 199    /// </summary>
 200    public static GovernanceOutboxEntry Create(
 201        GovernanceEmissionEnvelope envelope,
 202        string? outboxEntryId = null,
 203        DateTimeOffset? createdUtc = null,
 204        int maxRetryCount = DefaultMaxRetryCount,
 205        IReadOnlyDictionary<string, string>? metadata = null)
 206    {
 356207        DateTimeOffset timestamp = createdUtc ?? DateTimeOffset.UtcNow;
 208
 356209        return new GovernanceOutboxEntry(
 356210            NormalizeIdentifier(outboxEntryId),
 356211            envelope,
 356212            GovernanceEmissionStatus.Pending,
 356213            timestamp,
 356214            timestamp,
 356215            retryCount: 0,
 356216            maxRetryCount,
 356217            nextRetryUtc: null,
 356218            lastError: null,
 356219            providerName: null,
 356220            providerRecordId: null,
 356221            deadLetterReason: null,
 356222            NormalizeMetadata(metadata),
 356223            claimOwner: null,
 356224            claimToken: null,
 356225            claimedUtc: null,
 356226            claimExpiresUtc: null,
 356227            claimAttemptCount: 0);
 228    }
 229
 230    /// <summary>
 231    /// Restores a durable outbox entry from provider-neutral storage.
 232    /// </summary>
 233    /// <remarks>
 234    /// This factory exists for storage adapters. It does not perform provider emission and does not add any provider de
 235    /// </remarks>
 236    public static GovernanceOutboxEntry Restore(
 237        GovernanceEmissionEnvelope envelope,
 238        GovernanceEmissionStatus status,
 239        string outboxEntryId,
 240        DateTimeOffset createdUtc,
 241        DateTimeOffset updatedUtc,
 242        int retryCount = 0,
 243        int maxRetryCount = DefaultMaxRetryCount,
 244        DateTimeOffset? nextRetryUtc = null,
 245        GovernanceEmissionError? lastError = null,
 246        string? providerName = null,
 247        string? providerRecordId = null,
 248        string? deadLetterReason = null,
 249        IReadOnlyDictionary<string, string>? metadata = null,
 250        string? claimOwner = null,
 251        string? claimToken = null,
 252        DateTimeOffset? claimedUtc = null,
 253        DateTimeOffset? claimExpiresUtc = null,
 254        int claimAttemptCount = 0)
 255    {
 568256        return new GovernanceOutboxEntry(
 568257            outboxEntryId,
 568258            envelope,
 568259            status,
 568260            createdUtc,
 568261            updatedUtc,
 568262            retryCount,
 568263            maxRetryCount,
 568264            nextRetryUtc,
 568265            lastError,
 568266            providerName,
 568267            providerRecordId,
 568268            deadLetterReason,
 568269            NormalizeMetadata(metadata),
 568270            claimOwner,
 568271            claimToken,
 568272            claimedUtc,
 568273            claimExpiresUtc,
 568274            claimAttemptCount);
 275    }
 276
 277    /// <summary>
 278    /// Determines whether the entry is ready for retry at the supplied UTC timestamp.
 279    /// </summary>
 280    public bool IsRetryReady(DateTimeOffset utcNow)
 281    {
 70282        return !IsDelivered && !IsDeadLettered && Status is GovernanceEmissionStatus.Deferred or GovernanceEmissionStatu
 283    }
 284
 285    /// <summary>
 286    /// Determines whether the entry has an active claim lease at the supplied UTC timestamp.
 287    /// </summary>
 288    public bool HasActiveClaim(DateTimeOffset utcNow)
 289    {
 91290        return HasClaim && ClaimExpiresUtc > utcNow.ToUniversalTime();
 291    }
 292
 293    /// <summary>
 294    /// Determines whether the entry may be claimed by a cooperating worker at the supplied UTC timestamp.
 295    /// </summary>
 296    public bool CanBeClaimed(DateTimeOffset utcNow)
 297    {
 89298        return !IsDelivered && !IsDeadLettered && !HasActiveClaim(utcNow);
 299    }
 300
 301    /// <summary>
 302    /// Determines whether the entry is still owned by the supplied claim token.
 303    /// </summary>
 304    public bool IsClaimedBy(GovernanceOutboxClaim claim)
 305    {
 82306        ArgumentNullException.ThrowIfNull(claim);
 307
 82308        return string.Equals(OutboxEntryId, claim.OutboxEntryId, StringComparison.Ordinal)
 82309            && string.Equals(ClaimOwner, claim.WorkerId, StringComparison.Ordinal)
 82310            && string.Equals(ClaimToken, claim.ClaimToken, StringComparison.Ordinal);
 311    }
 312
 313    /// <summary>
 314    /// Returns a claimed copy of this entry.
 315    /// </summary>
 316    public GovernanceOutboxEntry MarkClaimed(
 317        string claimOwner,
 318        string? claimToken = null,
 319        DateTimeOffset? claimedUtc = null,
 320        TimeSpan? leaseDuration = null)
 321    {
 47322        ArgumentException.ThrowIfNullOrWhiteSpace(claimOwner);
 323
 47324        DateTimeOffset normalizedClaimedUtc = (claimedUtc ?? DateTimeOffset.UtcNow).ToUniversalTime();
 47325        TimeSpan normalizedLeaseDuration = leaseDuration ?? GovernanceOutboxClaimRequest.DefaultLeaseDuration;
 326
 47327        return normalizedLeaseDuration <= TimeSpan.Zero
 47328            ? throw new ArgumentOutOfRangeException(nameof(leaseDuration), leaseDuration, "Lease duration must be greate
 47329            : Copy(
 47330            Status,
 47331            normalizedClaimedUtc,
 47332            RetryCount,
 47333            NextRetryUtc,
 47334            LastError,
 47335            ProviderName,
 47336            ProviderRecordId,
 47337            DeadLetterReason,
 47338            Metadata,
 47339            claimOwner.Trim(),
 47340            string.IsNullOrWhiteSpace(claimToken) ? Guid.NewGuid().ToString("N") : claimToken.Trim(),
 47341            normalizedClaimedUtc,
 47342            normalizedClaimedUtc.Add(normalizedLeaseDuration),
 47343            ClaimAttemptCount + 1);
 344    }
 345
 346    /// <summary>
 347    /// Returns a copy with claim lease fields cleared.
 348    /// </summary>
 349    public GovernanceOutboxEntry ReleaseClaim(DateTimeOffset? updatedUtc = null)
 350    {
 6351        return Copy(
 6352            Status,
 6353            updatedUtc,
 6354            RetryCount,
 6355            NextRetryUtc,
 6356            LastError,
 6357            ProviderName,
 6358            ProviderRecordId,
 6359            DeadLetterReason,
 6360            Metadata,
 6361            claimOwner: null,
 6362            claimToken: null,
 6363            claimedUtc: null,
 6364            claimExpiresUtc: null,
 6365            ClaimAttemptCount);
 366    }
 367
 368    /// <summary>
 369    /// Returns a delivered copy of this entry.
 370    /// </summary>
 371    public GovernanceOutboxEntry MarkDelivered(
 372        GovernanceEmissionResult result,
 373        DateTimeOffset? updatedUtc = null)
 374    {
 50375        ArgumentNullException.ThrowIfNull(result);
 376
 50377        return !result.IsSuccess
 50378            ? throw new ArgumentException("Delivered outbox transitions require a successful emission result.", nameof(r
 50379            : Copy(
 50380            GovernanceEmissionStatus.Delivered,
 50381            updatedUtc,
 50382            retryCount: RetryCount,
 50383            nextRetryUtc: null,
 50384            lastError: null,
 50385            providerName: result.ProviderName,
 50386            providerRecordId: result.ProviderRecordId,
 50387            deadLetterReason: null,
 50388            metadata: MergeMetadata(Metadata, result.Metadata),
 50389            claimOwner: null,
 50390            claimToken: null,
 50391            claimedUtc: null,
 50392            claimExpiresUtc: null,
 50393            ClaimAttemptCount);
 394    }
 395
 396    /// <summary>
 397    /// Returns a failed or retryable-failure copy of this entry.
 398    /// </summary>
 399    public GovernanceOutboxEntry MarkFailed(
 400        GovernanceEmissionError governanceEmissionError,
 401        DateTimeOffset? nextRetryUtc = null,
 402        DateTimeOffset? updatedUtc = null)
 403    {
 68404        ArgumentNullException.ThrowIfNull(governanceEmissionError);
 405
 68406        int nextRetryCount = RetryCount + 1;
 68407        GovernanceEmissionStatus nextStatus = governanceEmissionError.IsRetryable
 68408            ? GovernanceEmissionStatus.RetryableFailure
 68409            : GovernanceEmissionStatus.Failed;
 410
 68411        return Copy(
 68412            nextStatus,
 68413            updatedUtc,
 68414            nextRetryCount,
 68415            nextRetryUtc,
 68416            governanceEmissionError,
 68417            governanceEmissionError.ProviderName,
 68418            providerRecordId: null,
 68419            deadLetterReason: null,
 68420            Metadata,
 68421            claimOwner: null,
 68422            claimToken: null,
 68423            claimedUtc: null,
 68424            claimExpiresUtc: null,
 68425            ClaimAttemptCount);
 426    }
 427
 428    /// <summary>
 429    /// Returns a deferred copy of this entry.
 430    /// </summary>
 431    public GovernanceOutboxEntry MarkDeferred(
 432        GovernanceEmissionError? governanceEmissionError = null,
 433        DateTimeOffset? nextRetryUtc = null,
 434        DateTimeOffset? updatedUtc = null)
 435    {
 22436        return Copy(
 22437            GovernanceEmissionStatus.Deferred,
 22438            updatedUtc,
 22439            retryCount: RetryCount,
 22440            nextRetryUtc,
 22441            governanceEmissionError,
 22442            governanceEmissionError?.ProviderName,
 22443            providerRecordId: null,
 22444            deadLetterReason: null,
 22445            metadata: Metadata,
 22446            claimOwner: null,
 22447            claimToken: null,
 22448            claimedUtc: null,
 22449            claimExpiresUtc: null,
 22450            ClaimAttemptCount);
 451    }
 452
 453    /// <summary>
 454    /// Returns a dead-lettered copy of this entry.
 455    /// </summary>
 456    public GovernanceOutboxEntry MarkDeadLettered(
 457        GovernanceEmissionError governanceEmissionError,
 458        string? deadLetterReason = null,
 459        DateTimeOffset? updatedUtc = null)
 460    {
 20461        ArgumentNullException.ThrowIfNull(governanceEmissionError);
 462
 20463        return Copy(
 20464            GovernanceEmissionStatus.DeadLettered,
 20465            updatedUtc,
 20466            retryCount: RetryCount,
 20467            nextRetryUtc: null,
 20468            lastError: governanceEmissionError,
 20469            providerName: governanceEmissionError.ProviderName,
 20470            providerRecordId: null,
 20471            deadLetterReason: deadLetterReason ?? governanceEmissionError.Message,
 20472            metadata: Metadata,
 20473            claimOwner: null,
 20474            claimToken: null,
 20475            claimedUtc: null,
 20476            claimExpiresUtc: null,
 20477            ClaimAttemptCount);
 478    }
 479
 480    private GovernanceOutboxEntry Copy(
 481        GovernanceEmissionStatus status,
 482        DateTimeOffset? updatedUtc,
 483        int retryCount,
 484        DateTimeOffset? nextRetryUtc,
 485        GovernanceEmissionError? lastError,
 486        string? providerName,
 487        string? providerRecordId,
 488        string? deadLetterReason,
 489        IReadOnlyDictionary<string, string> metadata,
 490        string? claimOwner,
 491        string? claimToken,
 492        DateTimeOffset? claimedUtc,
 493        DateTimeOffset? claimExpiresUtc,
 494        int claimAttemptCount)
 495    {
 209496        return new GovernanceOutboxEntry(
 209497            OutboxEntryId,
 209498            Envelope,
 209499            status,
 209500            CreatedUtc,
 209501            updatedUtc ?? DateTimeOffset.UtcNow,
 209502            retryCount,
 209503            MaxRetryCount,
 209504            nextRetryUtc,
 209505            lastError,
 209506            providerName,
 209507            providerRecordId,
 209508            deadLetterReason,
 209509            metadata,
 209510            claimOwner,
 209511            claimToken,
 209512            claimedUtc,
 209513            claimExpiresUtc,
 209514            claimAttemptCount);
 515    }
 516
 517    private static string NormalizeIdentifier(string? identifier)
 518    {
 356519        return string.IsNullOrWhiteSpace(identifier)
 356520            ? Guid.NewGuid().ToString("N")
 356521            : identifier.Trim();
 522    }
 523
 524    private static string? NormalizeOptional(string? value)
 525    {
 5610526        return string.IsNullOrWhiteSpace(value)
 5610527            ? null
 5610528            : value.Trim();
 529    }
 530
 531    private static IReadOnlyDictionary<string, string> MergeMetadata(
 532        IReadOnlyDictionary<string, string> originalMetadata,
 533        IReadOnlyDictionary<string, string> resultMetadata)
 534    {
 48535        if (resultMetadata.Count == 0)
 536        {
 41537            return originalMetadata;
 538        }
 539
 7540        if (originalMetadata.Count == 0)
 541        {
 5542            return resultMetadata;
 543        }
 544
 2545        Dictionary<string, string> mergedMetadata = new(originalMetadata.Count + resultMetadata.Count, StringComparer.Or
 546
 10547        foreach (KeyValuePair<string, string> item in originalMetadata)
 548        {
 3549            mergedMetadata[item.Key] = item.Value;
 550        }
 551
 10552        foreach (KeyValuePair<string, string> item in resultMetadata)
 553        {
 3554            mergedMetadata[item.Key] = item.Value;
 555        }
 556
 2557        return new ReadOnlyDictionary<string, string>(mergedMetadata);
 558    }
 559
 560    private static IReadOnlyDictionary<string, string> NormalizeMetadata(
 561        IReadOnlyDictionary<string, string>? metadata)
 562    {
 924563        if (metadata is null || metadata.Count == 0)
 564        {
 858565            return EmptyMetadata;
 566        }
 567
 66568        Dictionary<string, string> normalizedMetadata = new(metadata.Count, StringComparer.Ordinal);
 569
 290570        foreach (KeyValuePair<string, string> item in metadata)
 571        {
 79572            if (string.IsNullOrWhiteSpace(item.Key))
 573            {
 574                continue;
 575            }
 576
 76577            normalizedMetadata[item.Key.Trim()] = item.Value?.Trim() ?? string.Empty;
 578        }
 579
 66580        return normalizedMetadata.Count == 0
 66581            ? EmptyMetadata
 66582            : new ReadOnlyDictionary<string, string>(normalizedMetadata);
 583    }
 584}

Methods/Properties

.cctor()
.ctor(System.String,AsiBackbone.Core.Emissions.GovernanceEmissionEnvelope,AsiBackbone.Core.Emissions.GovernanceEmissionStatus,System.DateTimeOffset,System.DateTimeOffset,System.Int32,System.Int32,System.Nullable`1<System.DateTimeOffset>,AsiBackbone.Core.Emissions.GovernanceEmissionError,System.String,System.String,System.String,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,System.String,System.String,System.Nullable`1<System.DateTimeOffset>,System.Nullable`1<System.DateTimeOffset>,System.Int32)
get_IsDelivered()
get_IsDeadLettered()
get_HasMetadata()
get_HasClaim()
Create(AsiBackbone.Core.Emissions.GovernanceEmissionEnvelope,System.String,System.Nullable`1<System.DateTimeOffset>,System.Int32,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>)
Restore(AsiBackbone.Core.Emissions.GovernanceEmissionEnvelope,AsiBackbone.Core.Emissions.GovernanceEmissionStatus,System.String,System.DateTimeOffset,System.DateTimeOffset,System.Int32,System.Int32,System.Nullable`1<System.DateTimeOffset>,AsiBackbone.Core.Emissions.GovernanceEmissionError,System.String,System.String,System.String,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,System.String,System.String,System.Nullable`1<System.DateTimeOffset>,System.Nullable`1<System.DateTimeOffset>,System.Int32)
IsRetryReady(System.DateTimeOffset)
HasActiveClaim(System.DateTimeOffset)
CanBeClaimed(System.DateTimeOffset)
IsClaimedBy(AsiBackbone.Core.Outbox.GovernanceOutboxClaim)
MarkClaimed(System.String,System.String,System.Nullable`1<System.DateTimeOffset>,System.Nullable`1<System.TimeSpan>)
ReleaseClaim(System.Nullable`1<System.DateTimeOffset>)
MarkDelivered(AsiBackbone.Core.Emissions.GovernanceEmissionResult,System.Nullable`1<System.DateTimeOffset>)
MarkFailed(AsiBackbone.Core.Emissions.GovernanceEmissionError,System.Nullable`1<System.DateTimeOffset>,System.Nullable`1<System.DateTimeOffset>)
MarkDeferred(AsiBackbone.Core.Emissions.GovernanceEmissionError,System.Nullable`1<System.DateTimeOffset>,System.Nullable`1<System.DateTimeOffset>)
MarkDeadLettered(AsiBackbone.Core.Emissions.GovernanceEmissionError,System.String,System.Nullable`1<System.DateTimeOffset>)
Copy(AsiBackbone.Core.Emissions.GovernanceEmissionStatus,System.Nullable`1<System.DateTimeOffset>,System.Int32,System.Nullable`1<System.DateTimeOffset>,AsiBackbone.Core.Emissions.GovernanceEmissionError,System.String,System.String,System.String,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,System.String,System.String,System.Nullable`1<System.DateTimeOffset>,System.Nullable`1<System.DateTimeOffset>,System.Int32)
NormalizeIdentifier(System.String)
NormalizeOptional(System.String)
MergeMetadata(System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>)
NormalizeMetadata(System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>)