@yielded/auth 0.1.0-beta.1

package/dist/proofs/definition.d.mts

@@ -0,0 +1,335 @@
+import { AssuranceRequired, AuthenticationRequired, InvalidOperationInput, OperationForbidden, OperationPrivateOutputUnsupported } from "../operations/errors.mjs";
+import { AuthOperationResult } from "../operations/credentials.mjs";
+import { AuthOperation, OperationHandler } from "../operations/operation.mjs";
+import { HookDenied } from "../hooks/models.mjs";
+import { LifecycleHooks } from "../hooks/LifecycleHooks.mjs";
+import { PreparedCommit } from "../hooks/commit.mjs";
+import { SubtleCrypto } from "../WebCrypto.mjs";
+import "../Operations.mjs";
+import "../Hooks.mjs";
+import "../Auth.mjs";
+import { ProofBinding, ProofCleanupResult, ProofCompletionDecision, ProofId } from "./models.mjs";
+import { ProofCapabilityUnsupported, ProofConfigurationError, ProofIngressDenied, ProofInvalid, ProofRequestConflict, ProofUnavailable } from "./errors.mjs";
+import { EmailProofDelivery } from "./EmailProofDelivery.mjs";
+import { ProofPersistence } from "./ProofPersistence.mjs";
+import { PreparedProofDispatch, ProofIssuePlan } from "./dispatch.mjs";
+import { ProofCompletionPlan } from "./completion.mjs";
+import { SmsProofDelivery } from "./SmsProofDelivery.mjs";
+import { ProofModule, makeProofModule } from "./module.mjs";
+import { Schema } from "effect";
+//#region src/proofs/definition.d.ts
+type Options<Binding extends Schema.Codec<ProofBinding, unknown, unknown, unknown>> = Parameters<typeof makeProofModule<string, Binding>>[1];
+type NamespaceOf<Id> = Id extends string ? Id : "effect-auth/proofs";
+declare const define: <Binding extends Schema.Codec<ProofBinding, unknown, unknown, unknown>, const Id extends string | undefined>(namespace: Id, options: Options<Binding>) => Readonly<{
+  Proofs: import("effect/Context").Service<ProofModule<NamespaceOf<Id>, Binding["Type"]>, {
+    readonly planIssue: (input: {
+      readonly requestId: string & import("effect/Brand").Brand<"effect-auth/ProofRequestId">;
+      readonly binding: Binding["Type"];
+      readonly locale: string;
+      readonly eligible: boolean;
+    } & {
+      readonly supersedes?: ProofId;
+    }) => import("effect/Effect").Effect<ProofIssuePlan, HookDenied | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable>;
+    readonly prepareIssue: (input: {
+      readonly requestId: string & import("effect/Brand").Brand<"effect-auth/ProofRequestId">;
+      readonly binding: Binding["Type"];
+      readonly locale: string;
+      readonly eligible: boolean;
+    } & {
+      readonly supersedes?: ProofId;
+    }) => import("effect/Effect").Effect<PreparedCommit<PreparedProofDispatch>, HookDenied | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable>;
+    readonly prepareAttempt: (input: {
+      readonly reference: {
+        readonly proofId: string & import("effect/Brand").Brand<"effect-auth/ProofId">;
+        readonly purpose: string & import("effect/Brand").Brand<"effect-auth/ProofPurpose">;
+        readonly keyId: string;
+      };
+      readonly binding: Binding["Type"];
+      readonly credential: import("effect/Redacted").Redacted<string>;
+    }) => import("effect/Effect").Effect<PreparedCommit<AuthOperationResult<{
+      readonly _tag: "Accepted";
+      readonly continuation: {
+        readonly continuationId: string & import("effect/Brand").Brand<"effect-auth/ProofContinuationId">;
+        readonly purpose: string & import("effect/Brand").Brand<"effect-auth/ProofPurpose">;
+        readonly expiresAtMillis: number;
+      };
+    }> | {
+      readonly value: {
+        readonly _tag: "Rejected";
+      };
+      readonly credentialCommands: readonly [];
+    }>, HookDenied | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable, never>;
+    readonly planComplete: (input: {
+      readonly continuationId: string & import("effect/Brand").Brand<"effect-auth/ProofContinuationId">;
+      readonly binding: Binding["Type"];
+      readonly credential: import("effect/Redacted").Redacted<string>;
+    }) => import("effect/Effect").Effect<ProofCompletionPlan, HookDenied | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable>;
+    readonly prepareComplete: (input: {
+      readonly continuationId: string & import("effect/Brand").Brand<"effect-auth/ProofContinuationId">;
+      readonly binding: Binding["Type"];
+      readonly credential: import("effect/Redacted").Redacted<string>;
+    }) => import("effect/Effect").Effect<PreparedCommit<ProofCompletionDecision>, HookDenied | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable>;
+    readonly cancel: (binding: Binding["Type"]) => import("effect/Effect").Effect<PreparedCommit<void>, HookDenied | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable>;
+    readonly cleanup: (limit: number) => import("effect/Effect").Effect<PreparedCommit<ProofCleanupResult>, HookDenied | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable>;
+  }>;
+  emailLayer: import("effect/Layer").Layer<ProofModule<NamespaceOf<Id>, Binding["Type"]>, ProofConfigurationError, import("effect/Crypto").Crypto | EmailProofDelivery | LifecycleHooks | ProofPersistence | SubtleCrypto | Exclude<Binding["DecodingServices"], import("effect/Scope").Scope> | Exclude<Binding["EncodingServices"], import("effect/Scope").Scope>>;
+  smsLayer: import("effect/Layer").Layer<ProofModule<NamespaceOf<Id>, Binding["Type"]>, ProofConfigurationError, import("effect/Crypto").Crypto | LifecycleHooks | ProofPersistence | SmsProofDelivery | SubtleCrypto | Exclude<Binding["DecodingServices"], import("effect/Scope").Scope> | Exclude<Binding["EncodingServices"], import("effect/Scope").Scope>>;
+  handlersLayer: import("effect/Layer").Layer<OperationHandler<`${NamespaceOf<Id>}/attempt`, {
+    readonly reference: {
+      readonly proofId: string & import("effect/Brand").Brand<"effect-auth/ProofId">;
+      readonly purpose: string & import("effect/Brand").Brand<"effect-auth/ProofPurpose">;
+      readonly keyId: string;
+    };
+    readonly binding: Binding["Type"];
+    readonly credential: import("effect/Redacted").Redacted<string>;
+  }, {
+    readonly _tag: "Accepted";
+    readonly continuation: {
+      readonly continuationId: string & import("effect/Brand").Brand<"effect-auth/ProofContinuationId">;
+      readonly purpose: string & import("effect/Brand").Brand<"effect-auth/ProofPurpose">;
+      readonly expiresAtMillis: number;
+    };
+  }, AssuranceRequired | AuthenticationRequired | HookDenied | InvalidOperationInput | OperationForbidden | OperationPrivateOutputUnsupported | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable> | OperationHandler<`${NamespaceOf<Id>}/cancel`, {
+    readonly binding: Binding["Type"];
+  }, void, AssuranceRequired | AuthenticationRequired | HookDenied | InvalidOperationInput | OperationForbidden | OperationPrivateOutputUnsupported | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable> | OperationHandler<`${NamespaceOf<Id>}/cleanup`, {
+    readonly limit: number;
+  }, {
+    readonly removed: number;
+    readonly hasMore: boolean;
+  }, AssuranceRequired | AuthenticationRequired | HookDenied | InvalidOperationInput | OperationForbidden | OperationPrivateOutputUnsupported | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable> | OperationHandler<`${NamespaceOf<Id>}/complete`, {
+    readonly continuationId: string & import("effect/Brand").Brand<"effect-auth/ProofContinuationId">;
+    readonly binding: Binding["Type"];
+    readonly credential: import("effect/Redacted").Redacted<string>;
+  }, void, AssuranceRequired | AuthenticationRequired | HookDenied | InvalidOperationInput | OperationForbidden | OperationPrivateOutputUnsupported | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable> | OperationHandler<`${NamespaceOf<Id>}/request`, {
+    readonly requestId: string & import("effect/Brand").Brand<"effect-auth/ProofRequestId">;
+    readonly binding: Binding["Type"];
+    readonly locale: string;
+    readonly eligible: boolean;
+  }, {
+    readonly requestId: string & import("effect/Brand").Brand<"effect-auth/ProofRequestId">;
+    readonly reference: {
+      readonly proofId: string & import("effect/Brand").Brand<"effect-auth/ProofId">;
+      readonly purpose: string & import("effect/Brand").Brand<"effect-auth/ProofPurpose">;
+      readonly keyId: string;
+    };
+  }, AssuranceRequired | AuthenticationRequired | HookDenied | InvalidOperationInput | OperationForbidden | OperationPrivateOutputUnsupported | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable> | OperationHandler<`${NamespaceOf<Id>}/resend`, {
+    readonly requestId: string & import("effect/Brand").Brand<"effect-auth/ProofRequestId">;
+    readonly binding: Binding["Type"];
+    readonly locale: string;
+    readonly eligible: boolean;
+    readonly supersedes: string & import("effect/Brand").Brand<"effect-auth/ProofId">;
+  }, {
+    readonly requestId: string & import("effect/Brand").Brand<"effect-auth/ProofRequestId">;
+    readonly reference: {
+      readonly proofId: string & import("effect/Brand").Brand<"effect-auth/ProofId">;
+      readonly purpose: string & import("effect/Brand").Brand<"effect-auth/ProofPurpose">;
+      readonly keyId: string;
+    };
+  }, AssuranceRequired | AuthenticationRequired | HookDenied | InvalidOperationInput | OperationForbidden | OperationPrivateOutputUnsupported | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable>, never, ProofModule<NamespaceOf<Id>, Binding["Type"]>>;
+  operations: {
+    Request: AuthOperation<`${NamespaceOf<Id>}/request`, Schema.Struct<{
+      readonly requestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+      readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+      readonly locale: Schema.String;
+      readonly eligible: Schema.Boolean;
+    }>, Schema.Struct<{
+      readonly requestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+      readonly reference: Schema.Struct<{
+        readonly proofId: Schema.brand<Schema.String, "effect-auth/ProofId">;
+        readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+        readonly keyId: Schema.String;
+      }>;
+    }>, Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>, never, {
+      readonly payload: Schema.Struct<{
+        readonly requestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+        readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+        readonly locale: Schema.String;
+        readonly eligible: Schema.Boolean;
+      }>;
+      readonly success: Schema.Struct<{
+        readonly requestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+        readonly reference: Schema.Struct<{
+          readonly proofId: Schema.brand<Schema.String, "effect-auth/ProofId">;
+          readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+          readonly keyId: Schema.String;
+        }>;
+      }>;
+      readonly error: Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>;
+      readonly access: "system";
+      readonly replay: "idempotent";
+    }>;
+    Resend: AuthOperation<`${NamespaceOf<Id>}/resend`, Schema.Struct<{
+      readonly requestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+      readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+      readonly locale: Schema.String;
+      readonly eligible: Schema.Boolean;
+      readonly supersedes: Schema.brand<Schema.String, "effect-auth/ProofId">;
+    }>, Schema.Struct<{
+      readonly requestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+      readonly reference: Schema.Struct<{
+        readonly proofId: Schema.brand<Schema.String, "effect-auth/ProofId">;
+        readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+        readonly keyId: Schema.String;
+      }>;
+    }>, Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>, never, {
+      readonly payload: Schema.Struct<{
+        readonly requestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+        readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+        readonly locale: Schema.String;
+        readonly eligible: Schema.Boolean;
+        readonly supersedes: Schema.brand<Schema.String, "effect-auth/ProofId">;
+      }>;
+      readonly success: Schema.Struct<{
+        readonly requestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+        readonly reference: Schema.Struct<{
+          readonly proofId: Schema.brand<Schema.String, "effect-auth/ProofId">;
+          readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+          readonly keyId: Schema.String;
+        }>;
+      }>;
+      readonly error: Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>;
+      readonly access: "system";
+      readonly replay: "idempotent";
+    }>;
+    Attempt: AuthOperation<`${NamespaceOf<Id>}/attempt`, Schema.Struct<{
+      readonly reference: Schema.Struct<{
+        readonly proofId: Schema.brand<Schema.String, "effect-auth/ProofId">;
+        readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+        readonly keyId: Schema.String;
+      }>;
+      readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+      readonly credential: Schema.RedactedFromValue<Schema.String>;
+    }>, Schema.TaggedStruct<"Accepted", {
+      readonly continuation: Schema.Struct<{
+        readonly continuationId: Schema.brand<Schema.String, "effect-auth/ProofContinuationId">;
+        readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+        readonly expiresAtMillis: Schema.Int;
+      }>;
+    }>, Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>, never, {
+      readonly payload: Schema.Struct<{
+        readonly reference: Schema.Struct<{
+          readonly proofId: Schema.brand<Schema.String, "effect-auth/ProofId">;
+          readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+          readonly keyId: Schema.String;
+        }>;
+        readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+        readonly credential: Schema.RedactedFromValue<Schema.String>;
+      }>;
+      readonly success: Schema.TaggedStruct<"Accepted", {
+        readonly continuation: Schema.Struct<{
+          readonly continuationId: Schema.brand<Schema.String, "effect-auth/ProofContinuationId">;
+          readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+          readonly expiresAtMillis: Schema.Int;
+        }>;
+      }>;
+      readonly error: Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>;
+      readonly access: "system";
+      readonly replay: "single-use";
+      readonly credentials: true;
+    }>;
+    Complete: AuthOperation<`${NamespaceOf<Id>}/complete`, Schema.Struct<{
+      readonly continuationId: Schema.brand<Schema.String, "effect-auth/ProofContinuationId">;
+      readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+      readonly credential: Schema.RedactedFromValue<Schema.String>;
+    }>, Schema.Void, Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>, never, {
+      readonly payload: Schema.Struct<{
+        readonly continuationId: Schema.brand<Schema.String, "effect-auth/ProofContinuationId">;
+        readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+        readonly credential: Schema.RedactedFromValue<Schema.String>;
+      }>;
+      readonly success: Schema.Void;
+      readonly error: Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>;
+      readonly access: "system";
+      readonly replay: "single-use";
+      readonly credentials: true;
+    }>;
+    Cancel: AuthOperation<`${NamespaceOf<Id>}/cancel`, Schema.Struct<{
+      readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+    }>, Schema.Void, Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>, never, {
+      readonly payload: Schema.Struct<{
+        readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+      }>;
+      readonly success: Schema.Void;
+      readonly error: Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>;
+      readonly access: "system";
+      readonly replay: "idempotent";
+    }>;
+    Cleanup: AuthOperation<`${NamespaceOf<Id>}/cleanup`, Schema.Struct<{
+      readonly limit: Schema.Int;
+    }>, Schema.Struct<{
+      readonly removed: Schema.Natural;
+      readonly hasMore: Schema.Boolean;
+    }>, Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>, never, {
+      readonly payload: Schema.Struct<{
+        readonly limit: Schema.Int;
+      }>;
+      readonly success: Schema.Struct<{
+        readonly removed: Schema.Natural;
+        readonly hasMore: Schema.Boolean;
+      }>;
+      readonly error: Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>;
+      readonly access: "system";
+      readonly replay: "idempotent";
+    }>;
+  };
+  group: import("effect/unstable/rpc/RpcGroup").RpcGroup<import("effect/unstable/rpc/Rpc").Rpc<`${NamespaceOf<Id>}/attempt`, Schema.Struct<{
+    readonly reference: Schema.Struct<{
+      readonly proofId: Schema.brand<Schema.String, "effect-auth/ProofId">;
+      readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+      readonly keyId: Schema.String;
+    }>;
+    readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+    readonly credential: Schema.RedactedFromValue<Schema.String>;
+  }>, Schema.TaggedStruct<"Accepted", {
+    readonly continuation: Schema.Struct<{
+      readonly continuationId: Schema.brand<Schema.String, "effect-auth/ProofContinuationId">;
+      readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+      readonly expiresAtMillis: Schema.Int;
+    }>;
+  }>, Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>, Schema.Union<readonly [typeof InvalidOperationInput, typeof AuthenticationRequired, typeof OperationForbidden, typeof AssuranceRequired, typeof OperationPrivateOutputUnsupported]>]>, never, never> | import("effect/unstable/rpc/Rpc").Rpc<`${NamespaceOf<Id>}/cancel`, Schema.Struct<{
+    readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+  }>, Schema.Void, Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>, Schema.Union<readonly [typeof InvalidOperationInput, typeof AuthenticationRequired, typeof OperationForbidden, typeof AssuranceRequired, typeof OperationPrivateOutputUnsupported]>]>, never, never> | import("effect/unstable/rpc/Rpc").Rpc<`${NamespaceOf<Id>}/cleanup`, Schema.Struct<{
+    readonly limit: Schema.Int;
+  }>, Schema.Struct<{
+    readonly removed: Schema.Natural;
+    readonly hasMore: Schema.Boolean;
+  }>, Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>, Schema.Union<readonly [typeof InvalidOperationInput, typeof AuthenticationRequired, typeof OperationForbidden, typeof AssuranceRequired, typeof OperationPrivateOutputUnsupported]>]>, never, never> | import("effect/unstable/rpc/Rpc").Rpc<`${NamespaceOf<Id>}/complete`, Schema.Struct<{
+    readonly continuationId: Schema.brand<Schema.String, "effect-auth/ProofContinuationId">;
+    readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+    readonly credential: Schema.RedactedFromValue<Schema.String>;
+  }>, Schema.Void, Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>, Schema.Union<readonly [typeof InvalidOperationInput, typeof AuthenticationRequired, typeof OperationForbidden, typeof AssuranceRequired, typeof OperationPrivateOutputUnsupported]>]>, never, never> | import("effect/unstable/rpc/Rpc").Rpc<`${NamespaceOf<Id>}/request`, Schema.Struct<{
+    readonly requestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+    readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+    readonly locale: Schema.String;
+    readonly eligible: Schema.Boolean;
+  }>, Schema.Struct<{
+    readonly requestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+    readonly reference: Schema.Struct<{
+      readonly proofId: Schema.brand<Schema.String, "effect-auth/ProofId">;
+      readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+      readonly keyId: Schema.String;
+    }>;
+  }>, Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>, Schema.Union<readonly [typeof InvalidOperationInput, typeof AuthenticationRequired, typeof OperationForbidden, typeof AssuranceRequired, typeof OperationPrivateOutputUnsupported]>]>, never, never> | import("effect/unstable/rpc/Rpc").Rpc<`${NamespaceOf<Id>}/resend`, Schema.Struct<{
+    readonly requestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+    readonly binding: Schema.Codec<Binding["Type"], Binding["Encoded"], Binding["DecodingServices"], Binding["EncodingServices"]>;
+    readonly locale: Schema.String;
+    readonly eligible: Schema.Boolean;
+    readonly supersedes: Schema.brand<Schema.String, "effect-auth/ProofId">;
+  }>, Schema.Struct<{
+    readonly requestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+    readonly reference: Schema.Struct<{
+      readonly proofId: Schema.brand<Schema.String, "effect-auth/ProofId">;
+      readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+      readonly keyId: Schema.String;
+    }>;
+  }>, Schema.Union<readonly [Schema.Union<readonly [Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>, typeof HookDenied]>, Schema.Union<readonly [typeof InvalidOperationInput, typeof AuthenticationRequired, typeof OperationForbidden, typeof AssuranceRequired, typeof OperationPrivateOutputUnsupported]>]>, never, never>>;
+}>;
+declare function make<Binding extends Schema.Codec<ProofBinding, unknown, unknown, unknown>, const Id extends string>(options: Options<Binding> & {
+  readonly namespace: Id;
+}): ReturnType<typeof define<Binding, Id>>;
+declare function make<Binding extends Schema.Codec<ProofBinding, unknown, unknown, unknown>, const Id extends string | undefined = undefined>(options: Options<Binding> & {
+  readonly namespace?: Id;
+}): ReturnType<typeof define<Binding, Id | undefined>>;
+//#endregion
+export { make };
+//# sourceMappingURL=definition.d.mts.map

package/dist/proofs/definition.mjs

@@ -0,0 +1,10 @@
+import { makeProofModule } from "./module.mjs";
+//#region src/proofs/definition.ts
+const define = (namespace, options) => makeProofModule(namespace ?? "effect-auth/proofs", options);
+function make(options) {
+	return define(options.namespace, options);
+}
+//#endregion
+export { make };
+
+//# sourceMappingURL=definition.mjs.map

package/dist/proofs/definition.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.mjs","names":[],"sources":["../../src/proofs/definition.ts"],"sourcesContent":["import type { Schema } from \"effect\";\n\nimport type { ProofBinding } from \"./models\";\nimport { makeProofModule } from \"./module\";\n\ntype Options<Binding extends Schema.Codec<ProofBinding, unknown, unknown, unknown>> = Parameters<\n  typeof makeProofModule<string, Binding>\n>[1];\n\ntype NamespaceOf<Id> = Id extends string ? Id : \"effect-auth/proofs\";\n\nconst define = <\n  Binding extends Schema.Codec<ProofBinding, unknown, unknown, unknown>,\n  const Id extends string | undefined,\n>(\n  namespace: Id,\n  options: Options<Binding>,\n) =>\n  // The required namespace argument preserves whether a default can be selected.\n  makeProofModule((namespace ?? \"effect-auth/proofs\") as NamespaceOf<Id>, options);\n\nexport function make<\n  Binding extends Schema.Codec<ProofBinding, unknown, unknown, unknown>,\n  const Id extends string,\n>(options: Options<Binding> & { readonly namespace: Id }): ReturnType<typeof define<Binding, Id>>;\n\nexport function make<\n  Binding extends Schema.Codec<ProofBinding, unknown, unknown, unknown>,\n  const Id extends string | undefined = undefined,\n>(\n  options: Options<Binding> & { readonly namespace?: Id },\n): ReturnType<typeof define<Binding, Id | undefined>>;\n\nexport function make<\n  Binding extends Schema.Codec<ProofBinding, unknown, unknown, unknown>,\n  const Id extends string | undefined,\n>(options: Options<Binding> & { readonly namespace?: Id }) {\n  return define(options.namespace, options);\n}\n"],"mappings":";;AAWA,MAAM,UAIJ,WACA,YAGA,gBAAiB,aAAa,sBAA0C,OAAO;AAcjF,SAAgB,KAGd,SAAyD;CACzD,OAAO,OAAO,QAAQ,WAAW,OAAO;AAC1C"}

package/dist/proofs/delivery.d.mts

@@ -0,0 +1,30 @@
+import { LoginIdentifier } from "../identity/models.mjs";
+import { ProofDeliveryId, ProofDeliveryOutcome, ProofPurpose, ProofReference } from "./models.mjs";
+import "./errors.mjs";
+import { Context, Effect, Layer, Redacted, Schema } from "effect";
+//#region src/proofs/delivery.d.ts
+interface ProofDeliveryMessage {
+  readonly deliveryId: ProofDeliveryId;
+  readonly purpose: ProofPurpose;
+  readonly reference: ProofReference;
+  readonly recipient: LoginIdentifier;
+  readonly secret: Redacted.Redacted<string>;
+  readonly format: "token" | "numeric-code";
+  readonly expiresAtMillis: number;
+  readonly template: string;
+  readonly locale: string;
+}
+declare const ProofVendorPolicy: Schema.Struct<{
+  readonly vendorId: Schema.String;
+  /** A consumer asserts the vendor deduplicates identical delivery IDs for this horizon. */
+  readonly idempotencyMillis: Schema.Natural;
+}>;
+type ProofVendorPolicy = typeof ProofVendorPolicy.Type;
+interface ProofDelivery {
+  readonly vendor: ProofVendorPolicy;
+  /** Acceptance by vendor is not delivery to the recipient. No diagnostic/body escapes this boundary. */
+  readonly send: (message: ProofDeliveryMessage) => Effect.Effect<ProofDeliveryOutcome>;
+}
+//#endregion
+export { ProofDelivery, ProofDeliveryMessage, ProofVendorPolicy };
+//# sourceMappingURL=delivery.d.mts.map

package/dist/proofs/delivery.mjs

@@ -0,0 +1,26 @@
+import { reportAuthFailure } from "../internal/diagnostics.mjs";
+import { ProofConfigurationError } from "./errors.mjs";
+import { ProofDeliveryOutcome } from "./models.mjs";
+import { Effect, Layer, Schema } from "effect";
+//#region src/proofs/delivery.ts
+const ProofVendorPolicy = Schema.Struct({
+	vendorId: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(128)),
+	/** A consumer asserts the vendor deduplicates identical delivery IDs for this horizon. */
+	idempotencyMillis: Schema.Natural
+});
+const proofDeliveryLayer = (service, vendor, send) => {
+	const configuration = { ...vendor };
+	const callback = send;
+	return Layer.effect(service, Effect.gen(function* () {
+		const checked = Object.freeze(yield* Schema.decodeEffect(ProofVendorPolicy)(configuration).pipe(Effect.mapError(() => ProofConfigurationError.make({ reason: "delivery" }))));
+		const services = yield* Effect.context();
+		return {
+			vendor: checked,
+			send: (message) => Effect.suspend(() => callback(message)).pipe(Effect.provide(services), Effect.flatMap(Schema.decodeEffect(ProofDeliveryOutcome)), Effect.catchCause((cause) => reportAuthFailure("proof-delivery", cause).pipe(Effect.as({ _tag: "Ambiguous" }))))
+		};
+	}));
+};
+//#endregion
+export { ProofVendorPolicy, proofDeliveryLayer };
+
+//# sourceMappingURL=delivery.mjs.map

package/dist/proofs/delivery.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery.mjs","names":[],"sources":["../../src/proofs/delivery.ts"],"sourcesContent":["import { Effect, Layer, type Context, type Redacted, Schema } from \"effect\";\n\nimport type { LoginIdentifier } from \"../identity/models\";\nimport { reportAuthFailure } from \"../internal/diagnostics\";\nimport { ProofConfigurationError } from \"./errors\";\nimport {\n  ProofDeliveryOutcome,\n  type ProofDeliveryId,\n  type ProofPurpose,\n  type ProofReference,\n} from \"./models\";\n\nexport interface ProofDeliveryMessage {\n  readonly deliveryId: ProofDeliveryId;\n  readonly purpose: ProofPurpose;\n  readonly reference: ProofReference;\n  readonly recipient: LoginIdentifier;\n  readonly secret: Redacted.Redacted<string>;\n  readonly format: \"token\" | \"numeric-code\";\n  readonly expiresAtMillis: number;\n  readonly template: string;\n  readonly locale: string;\n}\n\nexport const ProofVendorPolicy = Schema.Struct({\n  vendorId: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(128)),\n  /** A consumer asserts the vendor deduplicates identical delivery IDs for this horizon. */\n  idempotencyMillis: Schema.Natural,\n});\n\nexport type ProofVendorPolicy = typeof ProofVendorPolicy.Type;\n\nexport interface ProofDelivery {\n  readonly vendor: ProofVendorPolicy;\n  /** Acceptance by vendor is not delivery to the recipient. No diagnostic/body escapes this boundary. */\n  readonly send: (message: ProofDeliveryMessage) => Effect.Effect<ProofDeliveryOutcome>;\n}\n\nexport const proofDeliveryLayer = <Id, E, R>(\n  service: Context.Key<Id, ProofDelivery>,\n  vendor: ProofVendorPolicy,\n  send: (message: ProofDeliveryMessage) => Effect.Effect<ProofDeliveryOutcome, E, R>,\n) => {\n  const configuration = { ...vendor };\n  const callback = send;\n\n  return Layer.effect(\n    service,\n    Effect.gen(function* () {\n      const checked = Object.freeze(\n        yield* Schema.decodeEffect(ProofVendorPolicy)(configuration).pipe(\n          Effect.mapError(() => ProofConfigurationError.make({ reason: \"delivery\" })),\n        ),\n      );\n\n      const services = yield* Effect.context<R>();\n\n      return {\n        vendor: checked,\n        send: (message: ProofDeliveryMessage) =>\n          Effect.suspend(() => callback(message)).pipe(\n            Effect.provide(services),\n            Effect.flatMap(Schema.decodeEffect(ProofDeliveryOutcome)),\n            Effect.catchCause((cause) =>\n              reportAuthFailure(\"proof-delivery\", cause).pipe(\n                Effect.as({ _tag: \"Ambiguous\" as const }),\n              ),\n            ),\n          ),\n      };\n    }),\n  );\n};\n"],"mappings":";;;;;AAwBA,MAAa,oBAAoB,OAAO,OAAO;CAC7C,UAAU,OAAO,OAAO,MAAM,OAAO,YAAY,CAAC,GAAG,OAAO,YAAY,GAAG,CAAC;;CAE5E,mBAAmB,OAAO;AAC5B,CAAC;AAUD,MAAa,sBACX,SACA,QACA,SACG;CACH,MAAM,gBAAgB,EAAE,GAAG,OAAO;CAClC,MAAM,WAAW;CAEjB,OAAO,MAAM,OACX,SACA,OAAO,IAAI,aAAa;EACtB,MAAM,UAAU,OAAO,OACrB,OAAO,OAAO,aAAa,iBAAiB,CAAC,CAAC,aAAa,CAAC,CAAC,KAC3D,OAAO,eAAe,wBAAwB,KAAK,EAAE,QAAQ,WAAW,CAAC,CAAC,CAC5E,CACF;EAEA,MAAM,WAAW,OAAO,OAAO,QAAW;EAE1C,OAAO;GACL,QAAQ;GACR,OAAO,YACL,OAAO,cAAc,SAAS,OAAO,CAAC,CAAC,CAAC,KACtC,OAAO,QAAQ,QAAQ,GACvB,OAAO,QAAQ,OAAO,aAAa,oBAAoB,CAAC,GACxD,OAAO,YAAY,UACjB,kBAAkB,kBAAkB,KAAK,CAAC,CAAC,KACzC,OAAO,GAAG,EAAE,MAAM,YAAqB,CAAC,CAC1C,CACF,CACF;EACJ;CACF,CAAC,CACH;AACF"}

package/dist/proofs/dispatch.d.mts

@@ -0,0 +1,20 @@
+import { PreparedCommit } from "../hooks/commit.mjs";
+import { ProofDeliveryStatus, ProofRequestReceipt } from "./models.mjs";
+import { ProofCapabilityUnsupported, ProofRequestConflict, ProofUnavailable } from "./errors.mjs";
+import "./delivery.mjs";
+import "./policy.mjs";
+import "./ProofPersistence.mjs";
+import { Context, Effect } from "effect";
+//#region src/proofs/dispatch.d.ts
+/** Private process-local continuation. Its closure is neither an outbox nor an RPC value. */
+interface PreparedProofDispatch<R = never> {
+  readonly receipt: ProofRequestReceipt;
+  readonly dispatch: Effect.Effect<ProofDeliveryStatus, ProofCapabilityUnsupported, R>;
+}
+interface ProofIssuePlan {
+  readonly commit: Effect.Effect<PreparedCommit<PreparedProofDispatch>, ProofUnavailable | ProofRequestConflict>;
+}
+declare const readProofCommit: <A>(receipt: PreparedCommit<A>) => Effect.Effect<A, ProofUnavailable, never>;
+//#endregion
+export { PreparedProofDispatch, ProofIssuePlan, readProofCommit };
+//# sourceMappingURL=dispatch.d.mts.map

package/dist/proofs/dispatch.mjs

@@ -0,0 +1,54 @@
+import { LoginIdentifier } from "../identity/models.mjs";
+import { hasCommitScope } from "../hooks/commit.mjs";
+import { ProofCapabilityUnsupported, ProofUnavailable } from "./errors.mjs";
+import { ProofPersistence } from "./ProofPersistence.mjs";
+import { DateTime, Effect } from "effect";
+//#region src/proofs/dispatch.ts
+const readProofCommit = (receipt) => receipt.read.pipe(Effect.mapError(() => ProofUnavailable.make({})));
+/** Call only from a prepared receipt, after its actual outer owner commits. */
+const makeProofDispatch = (deliveryKey, record, message, policy) => {
+	message = Object.freeze({
+		...message,
+		recipient: Object.freeze(LoginIdentifier.make(message.recipient)),
+		reference: Object.freeze({ ...message.reference })
+	});
+	return Object.freeze({
+		receipt: {
+			requestId: record.requestId,
+			reference: message.reference
+		},
+		dispatch: Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+			if (yield* hasCommitScope) return yield* ProofCapabilityUnsupported.make({});
+			const store = yield* ProofPersistence;
+			const delivery = yield* deliveryKey;
+			const claimResult = yield* store.claimDelivery({
+				moduleId: record.moduleId,
+				proofId: record.proofId,
+				version: record.version,
+				deliveryId: record.deliveryId,
+				nowMillis: DateTime.toEpochMillis(yield* DateTime.now),
+				policy,
+				allowAmbiguousRetry: policy.maximumDeliveryAttempts > 1 && delivery.vendor.idempotencyMillis >= policy.lifetimeMillis
+			}, (decision, journal) => journal.prepare(decision)).pipe(Effect.flatMap(readProofCommit), Effect.result);
+			if (claimResult._tag === "Failure") return "unavailable";
+			if (claimResult.success._tag === "Declined") return "not-dispatched";
+			const claimed = claimResult.success;
+			const sent = yield* Effect.exit(restore(Effect.suspend(() => delivery.send(message))));
+			const outcome = sent._tag === "Success" ? sent.value : { _tag: "Ambiguous" };
+			if ((yield* store.settleDelivery({
+				moduleId: record.moduleId,
+				proofId: record.proofId,
+				version: record.version,
+				deliveryId: record.deliveryId,
+				claimVersion: claimed.claimVersion,
+				outcome,
+				nowMillis: DateTime.toEpochMillis(yield* DateTime.now)
+			}, (_, journal) => journal.prepare(void 0)).pipe(Effect.flatMap(readProofCommit), Effect.result))._tag === "Failure") return "ambiguous";
+			return outcome._tag === "Accepted" ? "accepted" : outcome._tag === "DefiniteFailure" ? "failed" : "ambiguous";
+		}))
+	});
+};
+//#endregion
+export { makeProofDispatch, readProofCommit };
+
+//# sourceMappingURL=dispatch.mjs.map

package/dist/proofs/dispatch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.mjs","names":[],"sources":["../../src/proofs/dispatch.ts"],"sourcesContent":["import { type Context, DateTime, Effect } from \"effect\";\n\nimport { hasCommitScope, type PreparedCommit } from \"../hooks/commit\";\nimport { LoginIdentifier } from \"../identity/models\";\nimport type { ProofDelivery, ProofDeliveryMessage } from \"./delivery\";\nimport { ProofCapabilityUnsupported, ProofUnavailable } from \"./errors\";\nimport type { ProofDeliveryOutcome, ProofDeliveryStatus, ProofRequestReceipt } from \"./models\";\nimport type { ProofPolicy } from \"./policy\";\nimport { ProofPersistence, type ProofRecord } from \"./ProofPersistence\";\n\n/** Private process-local continuation. Its closure is neither an outbox nor an RPC value. */\nexport interface PreparedProofDispatch<R = never> {\n  readonly receipt: ProofRequestReceipt;\n  readonly dispatch: Effect.Effect<ProofDeliveryStatus, ProofCapabilityUnsupported, R>;\n}\n\nexport interface ProofIssuePlan {\n  readonly commit: Effect.Effect<\n    PreparedCommit<PreparedProofDispatch>,\n    ProofUnavailable | import(\"./errors\").ProofRequestConflict\n  >;\n}\n\nexport const readProofCommit = <A>(receipt: PreparedCommit<A>) =>\n  receipt.read.pipe(Effect.mapError(() => ProofUnavailable.make({})));\n\n/** Call only from a prepared receipt, after its actual outer owner commits. */\nexport const makeProofDispatch = <DeliveryId>(\n  deliveryKey: Context.Key<DeliveryId, ProofDelivery>,\n  record: ProofRecord,\n  message: ProofDeliveryMessage,\n  policy: ProofPolicy,\n): PreparedProofDispatch<ProofPersistence | DeliveryId> => {\n  message = Object.freeze({\n    ...message,\n    recipient: Object.freeze(LoginIdentifier.make(message.recipient)),\n    reference: Object.freeze({ ...message.reference }),\n  });\n\n  return Object.freeze({\n    receipt: { requestId: record.requestId, reference: message.reference },\n    dispatch: Effect.uninterruptibleMask((restore) =>\n      Effect.gen(function* () {\n        if (yield* hasCommitScope) return yield* ProofCapabilityUnsupported.make({});\n        const store = yield* ProofPersistence;\n        const delivery = yield* deliveryKey;\n\n        const claimResult = yield* store\n          .claimDelivery(\n            {\n              moduleId: record.moduleId,\n              proofId: record.proofId,\n              version: record.version,\n              deliveryId: record.deliveryId,\n              nowMillis: DateTime.toEpochMillis(yield* DateTime.now),\n              policy,\n              allowAmbiguousRetry:\n                policy.maximumDeliveryAttempts > 1 &&\n                delivery.vendor.idempotencyMillis >= policy.lifetimeMillis,\n            },\n            (decision, journal) => journal.prepare(decision),\n          )\n          .pipe(Effect.flatMap(readProofCommit), Effect.result);\n\n        if (claimResult._tag === \"Failure\") return \"unavailable\" as const;\n        if (claimResult.success._tag === \"Declined\") return \"not-dispatched\" as const;\n        const claimed = claimResult.success;\n        // After a durable claim, interruption/defect is potentially delivered. Always settle.\n        const sent = yield* Effect.exit(restore(Effect.suspend(() => delivery.send(message))));\n\n        const outcome: ProofDeliveryOutcome =\n          sent._tag === \"Success\" ? sent.value : { _tag: \"Ambiguous\" };\n\n        const settled = yield* store\n          .settleDelivery(\n            {\n              moduleId: record.moduleId,\n              proofId: record.proofId,\n              version: record.version,\n              deliveryId: record.deliveryId,\n              claimVersion: claimed.claimVersion,\n              outcome,\n              nowMillis: DateTime.toEpochMillis(yield* DateTime.now),\n            },\n            (_, journal) => journal.prepare(undefined),\n          )\n          .pipe(Effect.flatMap(readProofCommit), Effect.result);\n\n        if (settled._tag === \"Failure\") return \"ambiguous\" as const;\n\n        return outcome._tag === \"Accepted\"\n          ? (\"accepted\" as const)\n          : outcome._tag === \"DefiniteFailure\"\n            ? (\"failed\" as const)\n            : (\"ambiguous\" as const);\n      }),\n    ),\n  });\n};\n"],"mappings":";;;;;;AAuBA,MAAa,mBAAsB,YACjC,QAAQ,KAAK,KAAK,OAAO,eAAe,iBAAiB,KAAK,CAAC,CAAC,CAAC,CAAC;;AAGpE,MAAa,qBACX,aACA,QACA,SACA,WACyD;CACzD,UAAU,OAAO,OAAO;EACtB,GAAG;EACH,WAAW,OAAO,OAAO,gBAAgB,KAAK,QAAQ,SAAS,CAAC;EAChE,WAAW,OAAO,OAAO,EAAE,GAAG,QAAQ,UAAU,CAAC;CACnD,CAAC;CAED,OAAO,OAAO,OAAO;EACnB,SAAS;GAAE,WAAW,OAAO;GAAW,WAAW,QAAQ;EAAU;EACrE,UAAU,OAAO,qBAAqB,YACpC,OAAO,IAAI,aAAa;GACtB,IAAI,OAAO,gBAAgB,OAAO,OAAO,2BAA2B,KAAK,CAAC,CAAC;GAC3E,MAAM,QAAQ,OAAO;GACrB,MAAM,WAAW,OAAO;GAExB,MAAM,cAAc,OAAO,MACxB,cACC;IACE,UAAU,OAAO;IACjB,SAAS,OAAO;IAChB,SAAS,OAAO;IAChB,YAAY,OAAO;IACnB,WAAW,SAAS,cAAc,OAAO,SAAS,GAAG;IACrD;IACA,qBACE,OAAO,0BAA0B,KACjC,SAAS,OAAO,qBAAqB,OAAO;GAChD,IACC,UAAU,YAAY,QAAQ,QAAQ,QAAQ,CACjD,CAAC,CACA,KAAK,OAAO,QAAQ,eAAe,GAAG,OAAO,MAAM;GAEtD,IAAI,YAAY,SAAS,WAAW,OAAO;GAC3C,IAAI,YAAY,QAAQ,SAAS,YAAY,OAAO;GACpD,MAAM,UAAU,YAAY;GAE5B,MAAM,OAAO,OAAO,OAAO,KAAK,QAAQ,OAAO,cAAc,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC;GAErF,MAAM,UACJ,KAAK,SAAS,YAAY,KAAK,QAAQ,EAAE,MAAM,YAAY;GAiB7D,KAAI,OAfmB,MACpB,eACC;IACE,UAAU,OAAO;IACjB,SAAS,OAAO;IAChB,SAAS,OAAO;IAChB,YAAY,OAAO;IACnB,cAAc,QAAQ;IACtB;IACA,WAAW,SAAS,cAAc,OAAO,SAAS,GAAG;GACvD,IACC,GAAG,YAAY,QAAQ,QAAQ,KAAA,CAAS,CAC3C,CAAC,CACA,KAAK,OAAO,QAAQ,eAAe,GAAG,OAAO,MAAM,EAAA,CAE1C,SAAS,WAAW,OAAO;GAEvC,OAAO,QAAQ,SAAS,aACnB,aACD,QAAQ,SAAS,oBACd,WACA;EACT,CAAC,CACH;CACF,CAAC;AACH"}

package/dist/proofs/errors.d.mts

@@ -0,0 +1,21 @@
+import { Schema } from "effect";
+//#region src/proofs/errors.d.ts
+declare const ProofInvalid_base: Schema.Class<ProofInvalid, Schema.TaggedStruct<"ProofInvalid", {}>, import("effect/Cause").YieldableError>;
+declare class ProofInvalid extends ProofInvalid_base {}
+declare const ProofUnavailable_base: Schema.Class<ProofUnavailable, Schema.TaggedStruct<"ProofUnavailable", {}>, import("effect/Cause").YieldableError>;
+declare class ProofUnavailable extends ProofUnavailable_base {}
+declare const ProofConfigurationError_base: Schema.Class<ProofConfigurationError, Schema.TaggedStruct<"ProofConfigurationError", {
+  readonly reason: Schema.Literals<readonly ["policy", "keyring", "binding", "delivery", "unsupported-transaction"]>;
+}>, import("effect/Cause").YieldableError>;
+declare class ProofConfigurationError extends ProofConfigurationError_base {}
+declare const ProofRequestConflict_base: Schema.Class<ProofRequestConflict, Schema.TaggedStruct<"ProofRequestConflict", {}>, import("effect/Cause").YieldableError>;
+declare class ProofRequestConflict extends ProofRequestConflict_base {}
+declare const ProofCapabilityUnsupported_base: Schema.Class<ProofCapabilityUnsupported, Schema.TaggedStruct<"ProofCapabilityUnsupported", {}>, import("effect/Cause").YieldableError>;
+declare class ProofCapabilityUnsupported extends ProofCapabilityUnsupported_base {}
+declare const ProofIngressDenied_base: Schema.Class<ProofIngressDenied, Schema.TaggedStruct<"ProofIngressDenied", {}>, import("effect/Cause").YieldableError>;
+declare class ProofIngressDenied extends ProofIngressDenied_base {}
+declare const ProofError: Schema.Union<readonly [typeof ProofInvalid, typeof ProofUnavailable, typeof ProofRequestConflict, typeof ProofCapabilityUnsupported, typeof ProofIngressDenied]>;
+type ProofError = typeof ProofError.Type;
+//#endregion
+export { ProofCapabilityUnsupported, ProofConfigurationError, ProofError, ProofIngressDenied, ProofInvalid, ProofRequestConflict, ProofUnavailable };
+//# sourceMappingURL=errors.d.mts.map

package/dist/proofs/errors.mjs

@@ -0,0 +1,25 @@
+import { Schema } from "effect";
+//#region src/proofs/errors.ts
+var ProofInvalid = class extends Schema.TaggedError()("ProofInvalid", {}) {};
+var ProofUnavailable = class extends Schema.TaggedError()("ProofUnavailable", {}) {};
+var ProofConfigurationError = class extends Schema.TaggedError()("ProofConfigurationError", { reason: Schema.Literals([
+	"policy",
+	"keyring",
+	"binding",
+	"delivery",
+	"unsupported-transaction"
+]) }) {};
+var ProofRequestConflict = class extends Schema.TaggedError()("ProofRequestConflict", {}) {};
+var ProofCapabilityUnsupported = class extends Schema.TaggedError()("ProofCapabilityUnsupported", {}) {};
+var ProofIngressDenied = class extends Schema.TaggedError()("ProofIngressDenied", {}) {};
+const ProofError = Schema.Union([
+	ProofInvalid,
+	ProofUnavailable,
+	ProofRequestConflict,
+	ProofCapabilityUnsupported,
+	ProofIngressDenied
+]);
+//#endregion
+export { ProofCapabilityUnsupported, ProofConfigurationError, ProofError, ProofIngressDenied, ProofInvalid, ProofRequestConflict, ProofUnavailable };
+
+//# sourceMappingURL=errors.mjs.map

package/dist/proofs/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../../src/proofs/errors.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nexport class ProofInvalid extends Schema.TaggedError<ProofInvalid>()(\"ProofInvalid\", {}) {}\n\nexport class ProofUnavailable extends Schema.TaggedError<ProofUnavailable>()(\n  \"ProofUnavailable\",\n  {},\n) {}\n\nexport class ProofConfigurationError extends Schema.TaggedError<ProofConfigurationError>()(\n  \"ProofConfigurationError\",\n  {\n    reason: Schema.Literals([\n      \"policy\",\n      \"keyring\",\n      \"binding\",\n      \"delivery\",\n      \"unsupported-transaction\",\n    ]),\n  },\n) {}\n\nexport class ProofRequestConflict extends Schema.TaggedError<ProofRequestConflict>()(\n  \"ProofRequestConflict\",\n  {},\n) {}\n\nexport class ProofCapabilityUnsupported extends Schema.TaggedError<ProofCapabilityUnsupported>()(\n  \"ProofCapabilityUnsupported\",\n  {},\n) {}\n\nexport class ProofIngressDenied extends Schema.TaggedError<ProofIngressDenied>()(\n  \"ProofIngressDenied\",\n  {},\n) {}\n\nexport const ProofError = Schema.Union([\n  ProofInvalid,\n  ProofUnavailable,\n  ProofRequestConflict,\n  ProofCapabilityUnsupported,\n  ProofIngressDenied,\n]);\n\nexport type ProofError = typeof ProofError.Type;\n"],"mappings":";;AAEA,IAAa,eAAb,cAAkC,OAAO,YAA0B,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;AAE1F,IAAa,mBAAb,cAAsC,OAAO,YAA8B,CAAC,CAC1E,oBACA,CAAC,CACH,CAAC,CAAC,CAAC;AAEH,IAAa,0BAAb,cAA6C,OAAO,YAAqC,CAAC,CACxF,2BACA,EACE,QAAQ,OAAO,SAAS;CACtB;CACA;CACA;CACA;CACA;AACF,CAAC,EACH,CACF,CAAC,CAAC,CAAC;AAEH,IAAa,uBAAb,cAA0C,OAAO,YAAkC,CAAC,CAClF,wBACA,CAAC,CACH,CAAC,CAAC,CAAC;AAEH,IAAa,6BAAb,cAAgD,OAAO,YAAwC,CAAC,CAC9F,8BACA,CAAC,CACH,CAAC,CAAC,CAAC;AAEH,IAAa,qBAAb,cAAwC,OAAO,YAAgC,CAAC,CAC9E,sBACA,CAAC,CACH,CAAC,CAAC,CAAC;AAEH,MAAa,aAAa,OAAO,MAAM;CACrC;CACA;CACA;CACA;CACA;AACF,CAAC"}