@mannyc1/ts-release 0.0.7 → 0.2.2

package/dist/publication/report.d.ts

@@ -0,0 +1,1061 @@
+import * as Schema from "effect/Schema";
+import * as Result from "effect/Result";
+import { CanonicalAudience, CredentialPurpose, ProviderId, SubjectId } from "../model/authority.js";
+export declare const SafeReason: Schema.brand<Schema.String, "SafeReason">;
+export type SafeReason = typeof SafeReason.Type;
+declare const Difference_base: Schema.Class<Difference, Schema.Struct<{
+    readonly field: Schema.brand<Schema.NonEmptyString, "NonEmptyName">;
+    readonly expected: Schema.brand<Schema.String, "SafeReason">;
+    readonly observed: Schema.brand<Schema.String, "SafeReason">;
+}>, {}>;
+export declare class Difference extends Difference_base {
+}
+declare const AbsenceBasis_base: Schema.Class<AbsenceBasis, Schema.Struct<{
+    readonly kind: Schema.brand<Schema.NonEmptyString, "NonEmptyName">;
+    readonly detail: Schema.brand<Schema.String, "SafeReason">;
+}>, {}>;
+export declare class AbsenceBasis extends AbsenceBasis_base {
+}
+declare const VisibilityBasis_base: Schema.Class<VisibilityBasis, Schema.Struct<{
+    readonly kind: Schema.brand<Schema.NonEmptyString, "NonEmptyName">;
+    readonly detail: Schema.brand<Schema.String, "SafeReason">;
+}>, {}>;
+export declare class VisibilityBasis extends VisibilityBasis_base {
+}
+declare const PresentEquivalent_base: Schema.Class<PresentEquivalent, Schema.TaggedStruct<"PresentEquivalent", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+}>, {}>;
+export declare class PresentEquivalent extends PresentEquivalent_base {
+}
+declare const PresentDifferent_base: Schema.Class<PresentDifferent, Schema.TaggedStruct<"PresentDifferent", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly differences: Schema.NonEmptyArray<typeof Difference>;
+}>, {}>;
+export declare class PresentDifferent extends PresentDifferent_base {
+}
+declare const AuthoritativelyAbsent_base: Schema.Class<AuthoritativelyAbsent, Schema.TaggedStruct<"AuthoritativelyAbsent", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly basis: typeof AbsenceBasis;
+}>, {}>;
+export declare class AuthoritativelyAbsent extends AuthoritativelyAbsent_base {
+}
+declare const VisibilityPending_base: Schema.Class<VisibilityPending, Schema.TaggedStruct<"VisibilityPending", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly expectation: Schema.brand<Schema.String, "SafeReason">;
+    readonly basis: typeof VisibilityBasis;
+}>, {}>;
+export declare class VisibilityPending extends VisibilityPending_base {
+}
+declare const CredentialUnavailableCause_base: Schema.Class<CredentialUnavailableCause, Schema.TaggedStruct<"CredentialUnavailable", {
+    readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+    readonly purpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+    readonly strategy: Schema.Literals<readonly ["anonymous", "token", "trusted-publishing"]>;
+}>, {}>;
+/** Secret-free durable projection of a transient credential acquisition failure. */
+export declare class CredentialUnavailableCause extends CredentialUnavailableCause_base {
+}
+declare const CredentialStrategyUnsupportedCause_base: Schema.Class<CredentialStrategyUnsupportedCause, Schema.TaggedStruct<"CredentialStrategyUnsupported", {
+    readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+    readonly purpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+    readonly strategy: Schema.Literals<readonly ["anonymous", "token", "trusted-publishing"]>;
+}>, {}>;
+/** Secret-free durable projection of an unsupported prepared authentication strategy. */
+export declare class CredentialStrategyUnsupportedCause extends CredentialStrategyUnsupportedCause_base {
+}
+export declare const CredentialFailureCause: Schema.Union<readonly [typeof CredentialUnavailableCause, typeof CredentialStrategyUnsupportedCause]>;
+export type CredentialFailureCause = typeof CredentialFailureCause.Type;
+declare const InconclusiveObservation_base: Schema.Class<InconclusiveObservation, Schema.TaggedStruct<"Inconclusive", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly reason: Schema.brand<Schema.String, "SafeReason">;
+    readonly cause: Schema.optionalKey<Schema.Union<readonly [typeof CredentialUnavailableCause, typeof CredentialStrategyUnsupportedCause]>>;
+}>, {}>;
+export declare class InconclusiveObservation extends InconclusiveObservation_base {
+}
+export declare const Observation: Schema.Union<readonly [typeof PresentEquivalent, typeof PresentDifferent, typeof AuthoritativelyAbsent, typeof VisibilityPending, typeof InconclusiveObservation]>;
+export type Observation = typeof Observation.Type;
+declare const MutationPrecondition_base: Schema.Class<MutationPrecondition, Schema.Struct<{
+    readonly kind: Schema.brand<Schema.NonEmptyString, "NonEmptyName">;
+}>, {}>;
+export declare class MutationPrecondition extends MutationPrecondition_base {
+}
+declare const CreateAuthorizationProof_base: Schema.Class<CreateAuthorizationProof, Schema.Struct<{
+    readonly kind: Schema.brand<Schema.NonEmptyString, "NonEmptyName">;
+}>, {}>;
+export declare class CreateAuthorizationProof extends CreateAuthorizationProof_base {
+}
+declare const NeedsMutation_base: Schema.Class<NeedsMutation, Schema.TaggedStruct<"NeedsMutation", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly precondition: typeof MutationPrecondition;
+}>, {}>;
+export declare class NeedsMutation extends NeedsMutation_base {
+}
+declare const ProviderAuthorizedCreate_base: Schema.Class<ProviderAuthorizedCreate, Schema.TaggedStruct<"ProviderAuthorizedCreate", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly proof: typeof CreateAuthorizationProof;
+}>, {}>;
+export declare class ProviderAuthorizedCreate extends ProviderAuthorizedCreate_base {
+}
+export declare const MutationDecision: Schema.Union<readonly [typeof NeedsMutation, typeof ProviderAuthorizedCreate]>;
+export type MutationDecision = typeof MutationDecision.Type;
+declare const ProviderAlreadyEquivalent_base: Schema.Class<ProviderAlreadyEquivalent, Schema.TaggedStruct<"AlreadyEquivalent", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+}>, {}>;
+export declare class ProviderAlreadyEquivalent extends ProviderAlreadyEquivalent_base {
+}
+declare const Conflict_base: Schema.Class<Conflict, Schema.TaggedStruct<"Conflict", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly differences: Schema.NonEmptyArray<typeof Difference>;
+}>, {}>;
+export declare class Conflict extends Conflict_base {
+}
+declare const ProviderBlocked_base: Schema.Class<ProviderBlocked, Schema.TaggedStruct<"Blocked", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly reason: Schema.brand<Schema.String, "SafeReason">;
+    readonly cause: Schema.optionalKey<Schema.Union<readonly [typeof CredentialUnavailableCause, typeof CredentialStrategyUnsupportedCause]>>;
+}>, {}>;
+export declare class ProviderBlocked extends ProviderBlocked_base {
+}
+export declare const ProviderDecision: Schema.Union<readonly [typeof ProviderAlreadyEquivalent, typeof NeedsMutation, typeof ProviderAuthorizedCreate, typeof Conflict, typeof ProviderBlocked]>;
+export type ProviderDecision = typeof ProviderDecision.Type;
+declare const ProviderRejectionFact_base: Schema.Class<ProviderRejectionFact, Schema.Struct<{
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly code: Schema.brand<Schema.NonEmptyString, "NonEmptyName">;
+    readonly detail: Schema.brand<Schema.String, "SafeReason">;
+}>, {}>;
+export declare class ProviderRejectionFact extends ProviderRejectionFact_base {
+}
+declare const ProviderMutationFact_base: Schema.Class<ProviderMutationFact, Schema.Struct<{
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly detail: Schema.brand<Schema.String, "SafeReason">;
+}>, {}>;
+export declare class ProviderMutationFact extends ProviderMutationFact_base {
+}
+declare const RejectedBeforeDispatch_base: Schema.Class<RejectedBeforeDispatch, Schema.TaggedStruct<"RejectedBeforeDispatch", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly reason: Schema.brand<Schema.String, "SafeReason">;
+}>, {}>;
+export declare class RejectedBeforeDispatch extends RejectedBeforeDispatch_base {
+}
+declare const Started_base: Schema.Class<Started, Schema.TaggedStruct<"Started", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+}>, {}>;
+export declare class Started extends Started_base {
+}
+declare const RejectedByProvider_base: Schema.Class<RejectedByProvider, Schema.TaggedStruct<"RejectedByProvider", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly fact: typeof ProviderRejectionFact;
+}>, {}>;
+export declare class RejectedByProvider extends RejectedByProvider_base {
+}
+declare const Applied_base: Schema.Class<Applied, Schema.TaggedStruct<"Applied", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly fact: typeof ProviderMutationFact;
+}>, {}>;
+export declare class Applied extends Applied_base {
+}
+declare const OutcomeUnknown_base: Schema.Class<OutcomeUnknown, Schema.TaggedStruct<"OutcomeUnknown", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly reason: Schema.brand<Schema.String, "SafeReason">;
+}>, {}>;
+export declare class OutcomeUnknown extends OutcomeUnknown_base {
+}
+export declare const MutationAttempt: Schema.Union<readonly [typeof RejectedBeforeDispatch, typeof Started, typeof RejectedByProvider, typeof Applied, typeof OutcomeUnknown]>;
+export type MutationAttempt = typeof MutationAttempt.Type;
+export declare const AuthorityGrantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+export type AuthorityGrantKind = typeof AuthorityGrantKind.Type;
+declare const AuthorityAcquiredRecord_base: Schema.Class<AuthorityAcquiredRecord, Schema.TaggedStruct<"AuthorityAcquired", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+    readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+    readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+    readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+    readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+}>, {}>;
+declare class AuthorityAcquiredRecord extends AuthorityAcquiredRecord_base {
+}
+export declare const AuthorityAcquired: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+    readonly _tag: "AuthorityAcquired";
+    readonly subject: string;
+    readonly provider: string;
+    readonly audience: string;
+    readonly requestedPurpose: "observe" | "publish" | "correct";
+    readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+    readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+}, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+    readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+    readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+    readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+    readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+}>], {
+    readonly _tag: "AuthorityAcquired";
+    readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+    readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+    readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+    readonly requestedPurpose: "observe" | "publish" | "correct";
+    readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+    readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+}>, Schema.TaggedStruct<"AuthorityAcquired", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+    readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+    readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+    readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+    readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+}>, never, never>;
+export type AuthorityAcquired = typeof AuthorityAcquired.Type;
+declare const AuthorityAcquiredButMutationNotDispatchedRecord_base: Schema.Class<AuthorityAcquiredButMutationNotDispatchedRecord, Schema.TaggedStruct<"AuthorityAcquiredButMutationNotDispatched", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly authority: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>;
+    readonly attempt: typeof RejectedBeforeDispatch;
+}>, {}>;
+declare class AuthorityAcquiredButMutationNotDispatchedRecord extends AuthorityAcquiredButMutationNotDispatchedRecord_base {
+}
+export declare const AuthorityAcquiredButMutationNotDispatched: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredButMutationNotDispatchedRecord, {
+    readonly _tag: "AuthorityAcquiredButMutationNotDispatched";
+    readonly subject: string;
+    readonly authority: {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    };
+    readonly attempt: {
+        readonly _tag: "RejectedBeforeDispatch";
+        readonly subject: string;
+        readonly reason: string;
+    };
+}, readonly [Schema.TaggedStruct<"AuthorityAcquiredButMutationNotDispatched", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly authority: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>;
+    readonly attempt: typeof RejectedBeforeDispatch;
+}>], {
+    readonly _tag: "AuthorityAcquiredButMutationNotDispatched";
+    readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+    readonly authority: {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    };
+    readonly attempt: {
+        readonly _tag: "RejectedBeforeDispatch";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly reason: string & import("effect/Brand").Brand<"SafeReason">;
+    };
+}>, Schema.TaggedStruct<"AuthorityAcquiredButMutationNotDispatched", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly authority: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>;
+    readonly attempt: typeof RejectedBeforeDispatch;
+}>, never, never>;
+export type AuthorityAcquiredButMutationNotDispatched = typeof AuthorityAcquiredButMutationNotDispatched.Type;
+export declare const AuthorityEvidence: Schema.Union<readonly [Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+    readonly _tag: "AuthorityAcquired";
+    readonly subject: string;
+    readonly provider: string;
+    readonly audience: string;
+    readonly requestedPurpose: "observe" | "publish" | "correct";
+    readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+    readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+}, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+    readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+    readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+    readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+    readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+}>], {
+    readonly _tag: "AuthorityAcquired";
+    readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+    readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+    readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+    readonly requestedPurpose: "observe" | "publish" | "correct";
+    readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+    readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+}>, Schema.TaggedStruct<"AuthorityAcquired", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+    readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+    readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+    readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+    readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+}>, never, never>, Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredButMutationNotDispatchedRecord, {
+    readonly _tag: "AuthorityAcquiredButMutationNotDispatched";
+    readonly subject: string;
+    readonly authority: {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    };
+    readonly attempt: {
+        readonly _tag: "RejectedBeforeDispatch";
+        readonly subject: string;
+        readonly reason: string;
+    };
+}, readonly [Schema.TaggedStruct<"AuthorityAcquiredButMutationNotDispatched", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly authority: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>;
+    readonly attempt: typeof RejectedBeforeDispatch;
+}>], {
+    readonly _tag: "AuthorityAcquiredButMutationNotDispatched";
+    readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+    readonly authority: {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    };
+    readonly attempt: {
+        readonly _tag: "RejectedBeforeDispatch";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly reason: string & import("effect/Brand").Brand<"SafeReason">;
+    };
+}>, Schema.TaggedStruct<"AuthorityAcquiredButMutationNotDispatched", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly authority: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>;
+    readonly attempt: typeof RejectedBeforeDispatch;
+}>, never, never>]>;
+export type AuthorityEvidence = typeof AuthorityEvidence.Type;
+declare const DependencyBlocked_base: Schema.Class<DependencyBlocked, Schema.TaggedStruct<"DependencyBlocked", {
+    readonly prerequisite: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+}>, {}>;
+export declare class DependencyBlocked extends DependencyBlocked_base {
+}
+declare const RunAborted_base: Schema.Class<RunAborted, Schema.TaggedStruct<"RunAborted", {
+    readonly cause: Schema.brand<Schema.String, "SafeReason">;
+}>, {}>;
+export declare class RunAborted extends RunAborted_base {
+}
+export declare const NotReachedReason: Schema.Union<readonly [typeof DependencyBlocked, typeof RunAborted]>;
+export type NotReachedReason = typeof NotReachedReason.Type;
+declare const ConclusiveProviderRejection_base: Schema.Class<ConclusiveProviderRejection, Schema.TaggedStruct<"ConclusiveProviderRejection", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly fact: typeof ProviderRejectionFact;
+    readonly postObservations: Schema.NonEmptyArray<Schema.Union<readonly [typeof PresentEquivalent, typeof PresentDifferent, typeof AuthoritativelyAbsent, typeof VisibilityPending, typeof InconclusiveObservation]>>;
+}>, {}>;
+export declare class ConclusiveProviderRejection extends ConclusiveProviderRejection_base {
+}
+export declare const BlockedSubjectCause: Schema.Union<readonly [typeof Conflict, typeof ProviderBlocked, typeof RejectedBeforeDispatch, Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredButMutationNotDispatchedRecord, {
+    readonly _tag: "AuthorityAcquiredButMutationNotDispatched";
+    readonly subject: string;
+    readonly authority: {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    };
+    readonly attempt: {
+        readonly _tag: "RejectedBeforeDispatch";
+        readonly subject: string;
+        readonly reason: string;
+    };
+}, readonly [Schema.TaggedStruct<"AuthorityAcquiredButMutationNotDispatched", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly authority: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>;
+    readonly attempt: typeof RejectedBeforeDispatch;
+}>], {
+    readonly _tag: "AuthorityAcquiredButMutationNotDispatched";
+    readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+    readonly authority: {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    };
+    readonly attempt: {
+        readonly _tag: "RejectedBeforeDispatch";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly reason: string & import("effect/Brand").Brand<"SafeReason">;
+    };
+}>, Schema.TaggedStruct<"AuthorityAcquiredButMutationNotDispatched", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly authority: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>;
+    readonly attempt: typeof RejectedBeforeDispatch;
+}>, never, never>, typeof ConclusiveProviderRejection]>;
+export type BlockedSubjectCause = typeof BlockedSubjectCause.Type;
+declare const NotReachedRecord_base: Schema.Class<NotReachedRecord, Schema.TaggedStruct<"NotReached", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly reason: Schema.Union<readonly [typeof DependencyBlocked, typeof RunAborted]>;
+}>, {}>;
+declare class NotReachedRecord extends NotReachedRecord_base {
+}
+declare const AlreadyEquivalentRecord_base: Schema.Class<AlreadyEquivalentRecord, Schema.TaggedStruct<"AlreadyEquivalent", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly observationAuthorities: Schema.$Array<Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>>;
+    readonly observations: Schema.NonEmptyArray<Schema.Union<readonly [typeof PresentEquivalent, typeof PresentDifferent, typeof AuthoritativelyAbsent, typeof VisibilityPending, typeof InconclusiveObservation]>>;
+}>, {}>;
+declare class AlreadyEquivalentRecord extends AlreadyEquivalentRecord_base {
+}
+declare const ConvergedAfterMutationRecord_base: Schema.Class<ConvergedAfterMutationRecord, Schema.TaggedStruct<"ConvergedAfterMutation", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly observationAuthorities: Schema.$Array<Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>>;
+    readonly preObservations: Schema.NonEmptyArray<Schema.Union<readonly [typeof PresentEquivalent, typeof PresentDifferent, typeof AuthoritativelyAbsent, typeof VisibilityPending, typeof InconclusiveObservation]>>;
+    readonly decision: Schema.Union<readonly [typeof NeedsMutation, typeof ProviderAuthorizedCreate]>;
+    readonly authority: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>;
+    readonly attempt: Schema.Union<readonly [typeof Applied, typeof OutcomeUnknown, typeof RejectedByProvider]>;
+    readonly postObservations: Schema.NonEmptyArray<Schema.Union<readonly [typeof PresentEquivalent, typeof PresentDifferent, typeof AuthoritativelyAbsent, typeof VisibilityPending, typeof InconclusiveObservation]>>;
+}>, {}>;
+declare class ConvergedAfterMutationRecord extends ConvergedAfterMutationRecord_base {
+}
+declare const BlockedSubjectRecord_base: Schema.Class<BlockedSubjectRecord, Schema.TaggedStruct<"BlockedSubject", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly observationAuthorities: Schema.$Array<Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>>;
+    readonly observations: Schema.NonEmptyArray<Schema.Union<readonly [typeof PresentEquivalent, typeof PresentDifferent, typeof AuthoritativelyAbsent, typeof VisibilityPending, typeof InconclusiveObservation]>>;
+    readonly cause: Schema.Union<readonly [typeof Conflict, typeof ProviderBlocked, typeof RejectedBeforeDispatch, Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredButMutationNotDispatchedRecord, {
+        readonly _tag: "AuthorityAcquiredButMutationNotDispatched";
+        readonly subject: string;
+        readonly authority: {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string;
+            readonly provider: string;
+            readonly audience: string;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        };
+        readonly attempt: {
+            readonly _tag: "RejectedBeforeDispatch";
+            readonly subject: string;
+            readonly reason: string;
+        };
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquiredButMutationNotDispatched", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly authority: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string;
+            readonly provider: string;
+            readonly audience: string;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+            readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+            readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+            readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+            readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+            readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+            readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+        }>], {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        }>, Schema.TaggedStruct<"AuthorityAcquired", {
+            readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+            readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+            readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+            readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+            readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+            readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+        }>, never, never>;
+        readonly attempt: typeof RejectedBeforeDispatch;
+    }>], {
+        readonly _tag: "AuthorityAcquiredButMutationNotDispatched";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly authority: {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        };
+        readonly attempt: {
+            readonly _tag: "RejectedBeforeDispatch";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly reason: string & import("effect/Brand").Brand<"SafeReason">;
+        };
+    }>, Schema.TaggedStruct<"AuthorityAcquiredButMutationNotDispatched", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly authority: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string;
+            readonly provider: string;
+            readonly audience: string;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+            readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+            readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+            readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+            readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+            readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+            readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+        }>], {
+            readonly _tag: "AuthorityAcquired";
+            readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+            readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+            readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+            readonly requestedPurpose: "observe" | "publish" | "correct";
+            readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+            readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+        }>, Schema.TaggedStruct<"AuthorityAcquired", {
+            readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+            readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+            readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+            readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+            readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+            readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+        }>, never, never>;
+        readonly attempt: typeof RejectedBeforeDispatch;
+    }>, never, never>, typeof ConclusiveProviderRejection]>;
+}>, {}>;
+declare class BlockedSubjectRecord extends BlockedSubjectRecord_base {
+}
+declare const UncertainSubjectRecord_base: Schema.Class<UncertainSubjectRecord, Schema.TaggedStruct<"UncertainSubject", {
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly observationAuthorities: Schema.$Array<Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>>;
+    readonly observations: Schema.NonEmptyArray<Schema.Union<readonly [typeof PresentEquivalent, typeof PresentDifferent, typeof AuthoritativelyAbsent, typeof VisibilityPending, typeof InconclusiveObservation]>>;
+    readonly decision: Schema.optionalKey<Schema.Union<readonly [typeof ProviderAlreadyEquivalent, typeof NeedsMutation, typeof ProviderAuthorizedCreate, typeof Conflict, typeof ProviderBlocked]>>;
+    readonly authority: Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>;
+    readonly attempt: Schema.Union<readonly [typeof Started, typeof Applied, typeof OutcomeUnknown, typeof RejectedByProvider]>;
+    readonly trace: Schema.NonEmptyArray<Schema.Union<readonly [typeof PresentEquivalent, typeof PresentDifferent, typeof AuthoritativelyAbsent, typeof VisibilityPending, typeof InconclusiveObservation]>>;
+}>, {}>;
+declare class UncertainSubjectRecord extends UncertainSubjectRecord_base {
+}
+export type NotReached = typeof NotReachedRecord.Type;
+export type AlreadyEquivalent = typeof AlreadyEquivalentRecord.Type;
+export type ConvergedAfterMutation = typeof ConvergedAfterMutationRecord.Type;
+export type BlockedSubject = typeof BlockedSubjectRecord.Type;
+export type UncertainSubject = typeof UncertainSubjectRecord.Type;
+export declare const SubjectReport: Schema.Union<readonly [typeof NotReachedRecord, typeof AlreadyEquivalentRecord, typeof ConvergedAfterMutationRecord, typeof BlockedSubjectRecord, typeof UncertainSubjectRecord]>;
+export type SubjectReport = typeof SubjectReport.Type;
+declare const ReportConstructionError_base: Schema.Class<ReportConstructionError, Schema.TaggedStruct<"ReportConstructionError", {
+    readonly reason: Schema.brand<Schema.String, "SafeReason">;
+}>, import("effect/Cause").YieldableError>;
+export declare class ReportConstructionError extends ReportConstructionError_base {
+}
+export declare const makeAuthorityAcquired: (input: {
+    readonly subject: SubjectId;
+    readonly provider: ProviderId;
+    readonly audience: CanonicalAudience;
+    readonly requestedPurpose: CredentialPurpose;
+    readonly grantKind: AuthorityGrantKind;
+    readonly purposes: readonly [CredentialPurpose, ...Array<CredentialPurpose>];
+}) => Result.Result<AuthorityAcquired, ReportConstructionError>;
+export declare const makeAuthorityAcquiredButMutationNotDispatched: (input: {
+    readonly subject: SubjectId;
+    readonly authority: AuthorityAcquired;
+    readonly attempt: RejectedBeforeDispatch;
+}) => Result.Result<AuthorityAcquiredButMutationNotDispatched, ReportConstructionError>;
+export declare const makeNotReached: (subject: SubjectId, reason: NotReachedReason) => Result.Result<NotReached, ReportConstructionError>;
+export declare const makeAlreadyEquivalent: (subject: SubjectId, observations: readonly [Observation, ...Array<Observation>], observationAuthorities: ReadonlyArray<AuthorityAcquired>) => Result.Result<AlreadyEquivalent, ReportConstructionError>;
+export declare const makeConvergedAfterMutation: (input: {
+    readonly subject: SubjectId;
+    readonly observationAuthorities: ReadonlyArray<AuthorityAcquired>;
+    readonly preObservations: readonly [Observation, ...Array<Observation>];
+    readonly decision: MutationDecision;
+    readonly authority: AuthorityAcquired;
+    readonly attempt: Applied | OutcomeUnknown | RejectedByProvider;
+    readonly postObservations: readonly [Observation, ...Array<Observation>];
+}) => Result.Result<ConvergedAfterMutation, ReportConstructionError>;
+export declare const makeBlockedSubject: (input: {
+    readonly subject: SubjectId;
+    readonly observationAuthorities: ReadonlyArray<AuthorityAcquired>;
+    readonly observations: readonly [Observation, ...Array<Observation>];
+    readonly cause: BlockedSubjectCause;
+}) => Result.Result<BlockedSubject, ReportConstructionError>;
+export declare const makeUncertainSubject: (input: {
+    readonly subject: SubjectId;
+    readonly observationAuthorities: ReadonlyArray<AuthorityAcquired>;
+    readonly observations: readonly [Observation, ...Array<Observation>];
+    readonly decision?: ProviderDecision;
+    readonly authority: AuthorityAcquired;
+    readonly attempt: Started | Applied | OutcomeUnknown | RejectedByProvider;
+    readonly trace: readonly [Observation, ...Array<Observation>];
+}) => Result.Result<UncertainSubject, ReportConstructionError>;
+export declare const ReleaseStatus: Schema.Literals<readonly ["complete", "blocked", "uncertain"]>;
+export type ReleaseStatus = typeof ReleaseStatus.Type;
+export declare const ReleaseReport: Schema.Struct<{
+    readonly subjects: Schema.NonEmptyArray<Schema.Union<readonly [typeof NotReachedRecord, typeof AlreadyEquivalentRecord, typeof ConvergedAfterMutationRecord, typeof BlockedSubjectRecord, typeof UncertainSubjectRecord]>>;
+    readonly status: Schema.Literals<readonly ["complete", "blocked", "uncertain"]>;
+}>;
+export type ReleaseReport = typeof ReleaseReport.Type;
+export declare const makeReleaseReport: (subjects: readonly [SubjectReport, ...Array<SubjectReport>]) => ReleaseReport;
+declare const ReadOnlyEquivalent_base: Schema.Class<ReadOnlyEquivalent, Schema.TaggedStruct<"Equivalent", {}>, {}>;
+declare class ReadOnlyEquivalent extends ReadOnlyEquivalent_base {
+}
+declare const ReadOnlyDifferent_base: Schema.Class<ReadOnlyDifferent, Schema.TaggedStruct<"Different", {
+    readonly differences: Schema.NonEmptyArray<typeof Difference>;
+}>, {}>;
+declare class ReadOnlyDifferent extends ReadOnlyDifferent_base {
+}
+declare const ReadOnlyAbsent_base: Schema.Class<ReadOnlyAbsent, Schema.TaggedStruct<"Absent", {
+    readonly basis: typeof AbsenceBasis;
+}>, {}>;
+declare class ReadOnlyAbsent extends ReadOnlyAbsent_base {
+}
+declare const ReadOnlyInconclusive_base: Schema.Class<ReadOnlyInconclusive, Schema.TaggedStruct<"Inconclusive", {
+    readonly reason: Schema.brand<Schema.String, "SafeReason">;
+    readonly cause: Schema.optionalKey<Schema.Union<readonly [typeof CredentialUnavailableCause, typeof CredentialStrategyUnsupportedCause]>>;
+}>, {}>;
+declare class ReadOnlyInconclusive extends ReadOnlyInconclusive_base {
+}
+export declare const ObservationClassification: Schema.Union<readonly [typeof ReadOnlyEquivalent, typeof ReadOnlyDifferent, typeof ReadOnlyAbsent, typeof ReadOnlyInconclusive]>;
+export type ObservationClassification = typeof ObservationClassification.Type;
+export declare const equivalentObservation: () => ObservationClassification;
+export declare const differentObservation: (differences: readonly [Difference, ...Array<Difference>]) => ObservationClassification;
+export declare const absentObservation: (basis: AbsenceBasis) => ObservationClassification;
+export declare const inconclusiveObservation: (reason: SafeReason, cause?: CredentialFailureCause) => ObservationClassification;
+declare const ObservedSubject_base: Schema.Class<ObservedSubject, Schema.Struct<{
+    readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+    readonly observationAuthorities: Schema.$Array<Schema.decodeTo<Schema.declareConstructor<AuthorityAcquiredRecord, {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string;
+        readonly provider: string;
+        readonly audience: string;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }, readonly [Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>], {
+        readonly _tag: "AuthorityAcquired";
+        readonly subject: string & import("effect/Brand").Brand<"SubjectId">;
+        readonly provider: string & import("effect/Brand").Brand<"ProviderId">;
+        readonly audience: string & import("effect/Brand").Brand<"CanonicalAudience">;
+        readonly requestedPurpose: "observe" | "publish" | "correct";
+        readonly grantKind: "AnonymousAccess" | "ScopedSecret" | "WorkloadIdentity";
+        readonly purposes: readonly ["observe" | "publish" | "correct", ...("observe" | "publish" | "correct")[]];
+    }>, Schema.TaggedStruct<"AuthorityAcquired", {
+        readonly subject: Schema.brand<Schema.NonEmptyString, "SubjectId">;
+        readonly provider: Schema.brand<Schema.NonEmptyString, "ProviderId">;
+        readonly audience: Schema.brand<Schema.NonEmptyString, "CanonicalAudience">;
+        readonly requestedPurpose: Schema.Literals<readonly ["observe", "publish", "correct"]>;
+        readonly grantKind: Schema.Literals<readonly ["AnonymousAccess", "ScopedSecret", "WorkloadIdentity"]>;
+        readonly purposes: Schema.NonEmptyArray<Schema.Literals<readonly ["observe", "publish", "correct"]>>;
+    }>, never, never>>;
+    readonly observation: Schema.Union<readonly [typeof ReadOnlyEquivalent, typeof ReadOnlyDifferent, typeof ReadOnlyAbsent, typeof ReadOnlyInconclusive]>;
+}>, {}>;
+export declare class ObservedSubject extends ObservedSubject_base {
+}
+export declare const ObservationStatus: Schema.Literals<readonly ["equivalent", "different", "inconclusive"]>;
+export type ObservationStatus = typeof ObservationStatus.Type;
+export declare const ObservationReport: Schema.Struct<{
+    readonly subjects: Schema.NonEmptyArray<typeof ObservedSubject>;
+    readonly status: Schema.Literals<readonly ["equivalent", "different", "inconclusive"]>;
+}>;
+export type ObservationReport = typeof ObservationReport.Type;
+export declare const makeObservationReport: (subjects: readonly [ObservedSubject, ...Array<ObservedSubject>]) => ObservationReport;
+export {};
+//# sourceMappingURL=report.d.ts.map