@yielded/auth 0.1.0-beta.1

package/dist/proofs/models.d.mts

@@ -0,0 +1,141 @@
+import { LoginIdentifier } from "../identity/models.mjs";
+import { Schema } from "effect";
+//#region src/proofs/models.d.ts
+declare const ProofId: Schema.brand<Schema.String, "effect-auth/ProofId">;
+type ProofId = typeof ProofId.Type;
+declare const ProofRequestId: Schema.brand<Schema.String, "effect-auth/ProofRequestId">;
+type ProofRequestId = typeof ProofRequestId.Type;
+declare const ProofDeliveryId: Schema.brand<Schema.String, "effect-auth/ProofDeliveryId">;
+type ProofDeliveryId = typeof ProofDeliveryId.Type;
+declare const ProofContinuationId: Schema.brand<Schema.String, "effect-auth/ProofContinuationId">;
+type ProofContinuationId = typeof ProofContinuationId.Type;
+declare const ProofVersion: Schema.brand<Schema.String, "effect-auth/ProofVersion">;
+type ProofVersion = typeof ProofVersion.Type;
+declare const ProofPurpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+type ProofPurpose = typeof ProofPurpose.Type;
+declare const ProofInstant: Schema.Int;
+declare const IdentifierProofBinding: Schema.TaggedStruct<"Identifier", {
+  readonly flowId: Schema.String;
+  readonly contextDigest: Schema.brand<Schema.NonEmptyString, "effect-auth/TokenDigest">;
+  readonly identifier: Schema.compose<typeof LoginIdentifier, Schema.Struct<{
+    readonly namespace: Schema.NonEmptyString;
+    readonly value: Schema.NonEmptyString;
+  }>>;
+}>;
+declare const SubjectProofBinding: Schema.TaggedStruct<"Subject", {
+  readonly flowId: Schema.String;
+  readonly contextDigest: Schema.brand<Schema.NonEmptyString, "effect-auth/TokenDigest">;
+  readonly revision: Schema.Struct<{
+    readonly subjectId: Schema.brand<Schema.NonEmptyString, "effect-auth/SubjectId">;
+    readonly securityRevision: Schema.brand<Schema.NonEmptyString, "effect-auth/SecurityRevision">;
+    readonly credentials: Schema.$Array<Schema.Struct<{
+      readonly credentialId: Schema.NonEmptyString;
+      readonly revision: Schema.brand<Schema.NonEmptyString, "effect-auth/SecurityRevision">;
+    }>>;
+  }>;
+  readonly identifier: Schema.compose<typeof LoginIdentifier, Schema.Struct<{
+    readonly namespace: Schema.NonEmptyString;
+    readonly value: Schema.NonEmptyString;
+  }>>;
+}>;
+declare const IdentifierChangeProofBinding: Schema.TaggedStruct<"IdentifierChange", {
+  readonly flowId: Schema.String;
+  readonly contextDigest: Schema.brand<Schema.NonEmptyString, "effect-auth/TokenDigest">;
+  readonly revision: Schema.Struct<{
+    readonly subjectId: Schema.brand<Schema.NonEmptyString, "effect-auth/SubjectId">;
+    readonly securityRevision: Schema.brand<Schema.NonEmptyString, "effect-auth/SecurityRevision">;
+    readonly credentials: Schema.$Array<Schema.Struct<{
+      readonly credentialId: Schema.NonEmptyString;
+      readonly revision: Schema.brand<Schema.NonEmptyString, "effect-auth/SecurityRevision">;
+    }>>;
+  }>;
+  readonly identifier: Schema.compose<typeof LoginIdentifier, Schema.Struct<{
+    readonly namespace: Schema.NonEmptyString;
+    readonly value: Schema.NonEmptyString;
+  }>>;
+}>;
+declare const ProofBinding: Schema.Union<readonly [Schema.TaggedStruct<"Identifier", {
+  readonly flowId: Schema.String;
+  readonly contextDigest: Schema.brand<Schema.NonEmptyString, "effect-auth/TokenDigest">;
+  readonly identifier: Schema.compose<typeof LoginIdentifier, Schema.Struct<{
+    readonly namespace: Schema.NonEmptyString;
+    readonly value: Schema.NonEmptyString;
+  }>>;
+}>, Schema.TaggedStruct<"Subject", {
+  readonly flowId: Schema.String;
+  readonly contextDigest: Schema.brand<Schema.NonEmptyString, "effect-auth/TokenDigest">;
+  readonly revision: Schema.Struct<{
+    readonly subjectId: Schema.brand<Schema.NonEmptyString, "effect-auth/SubjectId">;
+    readonly securityRevision: Schema.brand<Schema.NonEmptyString, "effect-auth/SecurityRevision">;
+    readonly credentials: Schema.$Array<Schema.Struct<{
+      readonly credentialId: Schema.NonEmptyString;
+      readonly revision: Schema.brand<Schema.NonEmptyString, "effect-auth/SecurityRevision">;
+    }>>;
+  }>;
+  readonly identifier: Schema.compose<typeof LoginIdentifier, Schema.Struct<{
+    readonly namespace: Schema.NonEmptyString;
+    readonly value: Schema.NonEmptyString;
+  }>>;
+}>, Schema.TaggedStruct<"IdentifierChange", {
+  readonly flowId: Schema.String;
+  readonly contextDigest: Schema.brand<Schema.NonEmptyString, "effect-auth/TokenDigest">;
+  readonly revision: Schema.Struct<{
+    readonly subjectId: Schema.brand<Schema.NonEmptyString, "effect-auth/SubjectId">;
+    readonly securityRevision: Schema.brand<Schema.NonEmptyString, "effect-auth/SecurityRevision">;
+    readonly credentials: Schema.$Array<Schema.Struct<{
+      readonly credentialId: Schema.NonEmptyString;
+      readonly revision: Schema.brand<Schema.NonEmptyString, "effect-auth/SecurityRevision">;
+    }>>;
+  }>;
+  readonly identifier: Schema.compose<typeof LoginIdentifier, Schema.Struct<{
+    readonly namespace: Schema.NonEmptyString;
+    readonly value: Schema.NonEmptyString;
+  }>>;
+}>]>;
+type ProofBinding = typeof ProofBinding.Type;
+/** Same public shape for issued, duplicate, ineligible, and throttled requests. */
+declare const ProofReference: Schema.Struct<{
+  readonly proofId: Schema.brand<Schema.String, "effect-auth/ProofId">;
+  readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+  readonly keyId: Schema.String;
+}>;
+type ProofReference = typeof ProofReference.Type;
+declare const ProofRequestReceipt: 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;
+  }>;
+}>;
+type ProofRequestReceipt = typeof ProofRequestReceipt.Type;
+declare const ProofContinuation: Schema.Struct<{
+  readonly continuationId: Schema.brand<Schema.String, "effect-auth/ProofContinuationId">;
+  readonly purpose: Schema.brand<Schema.String, "effect-auth/ProofPurpose">;
+  readonly expiresAtMillis: Schema.Int;
+}>;
+type ProofContinuation = typeof ProofContinuation.Type;
+declare const ProofAttemptDecision: Schema.Union<readonly [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.TaggedStruct<"Rejected", {}>]>;
+type ProofAttemptDecision = typeof ProofAttemptDecision.Type;
+declare const ProofCompletionDecision: Schema.Literals<readonly ["completed", "rejected"]>;
+type ProofCompletionDecision = typeof ProofCompletionDecision.Type;
+declare const ProofDeliveryOutcome: Schema.Union<readonly [Schema.TaggedStruct<"Accepted", {}>, Schema.TaggedStruct<"DefiniteFailure", {
+  readonly reason: Schema.Literals<readonly ["recipient", "policy", "unavailable"]>;
+}>, Schema.TaggedStruct<"Ambiguous", {}>]>;
+type ProofDeliveryOutcome = typeof ProofDeliveryOutcome.Type;
+declare const ProofDeliveryStatus: Schema.Literals<readonly ["accepted", "failed", "ambiguous", "unavailable", "not-dispatched"]>;
+type ProofDeliveryStatus = typeof ProofDeliveryStatus.Type;
+declare const ProofCleanupResult: Schema.Struct<{
+  readonly removed: Schema.Natural;
+  readonly hasMore: Schema.Boolean;
+}>;
+type ProofCleanupResult = typeof ProofCleanupResult.Type;
+//#endregion
+export { IdentifierChangeProofBinding, IdentifierProofBinding, ProofAttemptDecision, ProofBinding, ProofCleanupResult, ProofCompletionDecision, ProofContinuation, ProofContinuationId, ProofDeliveryId, ProofDeliveryOutcome, ProofDeliveryStatus, ProofId, ProofInstant, ProofPurpose, ProofReference, ProofRequestId, ProofRequestReceipt, ProofVersion, SubjectProofBinding };
+//# sourceMappingURL=models.d.mts.map

package/dist/proofs/models.mjs

@@ -0,0 +1,93 @@
+import { TokenDigest } from "../Schema.mjs";
+import { LoginIdentifier } from "../identity/models.mjs";
+import { AuthenticationRevision, CredentialRevision } from "../sessions/models.mjs";
+import { Schema } from "effect";
+//#region src/proofs/models.ts
+const BoundedId = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256));
+const ProofId = BoundedId.pipe(Schema.brand("effect-auth/ProofId"));
+const ProofRequestId = BoundedId.pipe(Schema.brand("effect-auth/ProofRequestId"));
+const ProofDeliveryId = BoundedId.pipe(Schema.brand("effect-auth/ProofDeliveryId"));
+const ProofContinuationId = BoundedId.pipe(Schema.brand("effect-auth/ProofContinuationId"));
+const ProofVersion = BoundedId.pipe(Schema.brand("effect-auth/ProofVersion"));
+const ProofPurpose = BoundedId.pipe(Schema.brand("effect-auth/ProofPurpose"));
+const ProofInstant = Schema.Int.check(Schema.isBetween({
+	minimum: -864e13,
+	maximum: 864e13
+}));
+const BoundedIdentifier = Schema.Struct({
+	namespace: LoginIdentifier.fields.namespace.check(Schema.isMaxLength(256)),
+	value: LoginIdentifier.fields.value.check(Schema.isMaxLength(2048))
+}).pipe(Schema.decodeTo(LoginIdentifier));
+const BoundedRevision = Schema.Struct({
+	...AuthenticationRevision.fields,
+	subjectId: AuthenticationRevision.fields.subjectId.check(Schema.isMaxLength(256)),
+	securityRevision: AuthenticationRevision.fields.securityRevision.check(Schema.isMaxLength(256)),
+	credentials: Schema.Array(Schema.Struct({
+		credentialId: CredentialRevision.fields.credentialId.check(Schema.isMaxLength(256)),
+		revision: CredentialRevision.fields.revision.check(Schema.isMaxLength(256))
+	})).check(Schema.isMaxLength(32))
+});
+const FlowBinding = {
+	flowId: BoundedId,
+	contextDigest: TokenDigest.check(Schema.isMaxLength(256))
+};
+const IdentifierProofBinding = Schema.TaggedStruct("Identifier", {
+	...FlowBinding,
+	identifier: BoundedIdentifier
+});
+const SubjectProofBinding = Schema.TaggedStruct("Subject", {
+	...FlowBinding,
+	revision: BoundedRevision,
+	identifier: BoundedIdentifier
+});
+const IdentifierChangeProofBinding = Schema.TaggedStruct("IdentifierChange", {
+	...FlowBinding,
+	revision: BoundedRevision,
+	identifier: BoundedIdentifier
+});
+const ProofBinding = Schema.Union([
+	IdentifierProofBinding,
+	SubjectProofBinding,
+	IdentifierChangeProofBinding
+]);
+/** Same public shape for issued, duplicate, ineligible, and throttled requests. */
+const ProofReference = Schema.Struct({
+	proofId: ProofId,
+	purpose: ProofPurpose,
+	keyId: BoundedId
+});
+const ProofRequestReceipt = Schema.Struct({
+	requestId: ProofRequestId,
+	reference: ProofReference
+});
+const ProofContinuation = Schema.Struct({
+	continuationId: ProofContinuationId,
+	purpose: ProofPurpose,
+	expiresAtMillis: ProofInstant
+});
+const ProofAttemptDecision = Schema.Union([Schema.TaggedStruct("Accepted", { continuation: ProofContinuation }), Schema.TaggedStruct("Rejected", {})]);
+const ProofCompletionDecision = Schema.Literals(["completed", "rejected"]);
+const ProofDeliveryOutcome = Schema.Union([
+	Schema.TaggedStruct("Accepted", {}),
+	Schema.TaggedStruct("DefiniteFailure", { reason: Schema.Literals([
+		"recipient",
+		"policy",
+		"unavailable"
+	]) }),
+	Schema.TaggedStruct("Ambiguous", {})
+]);
+const ProofDeliveryStatus = Schema.Literals([
+	"accepted",
+	"failed",
+	"ambiguous",
+	"unavailable",
+	"not-dispatched"
+]);
+const ProofCleanupResult = Schema.Struct({
+	removed: Schema.Natural,
+	hasMore: Schema.Boolean
+});
+//#endregion
+export { IdentifierChangeProofBinding, IdentifierProofBinding, ProofAttemptDecision, ProofBinding, ProofCleanupResult, ProofCompletionDecision, ProofContinuation, ProofContinuationId, ProofDeliveryId, ProofDeliveryOutcome, ProofDeliveryStatus, ProofId, ProofInstant, ProofPurpose, ProofReference, ProofRequestId, ProofRequestReceipt, ProofVersion, SubjectProofBinding };
+
+//# sourceMappingURL=models.mjs.map

package/dist/proofs/models.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.mjs","names":[],"sources":["../../src/proofs/models.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { LoginIdentifier } from \"../identity/models\";\nimport { TokenDigest } from \"../Schema\";\nimport { AuthenticationRevision, CredentialRevision } from \"../sessions/models\";\n\nconst BoundedId = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256));\n\nexport const ProofId = BoundedId.pipe(Schema.brand(\"effect-auth/ProofId\"));\nexport type ProofId = typeof ProofId.Type;\nexport const ProofRequestId = BoundedId.pipe(Schema.brand(\"effect-auth/ProofRequestId\"));\nexport type ProofRequestId = typeof ProofRequestId.Type;\nexport const ProofDeliveryId = BoundedId.pipe(Schema.brand(\"effect-auth/ProofDeliveryId\"));\nexport type ProofDeliveryId = typeof ProofDeliveryId.Type;\nexport const ProofContinuationId = BoundedId.pipe(Schema.brand(\"effect-auth/ProofContinuationId\"));\nexport type ProofContinuationId = typeof ProofContinuationId.Type;\nexport const ProofVersion = BoundedId.pipe(Schema.brand(\"effect-auth/ProofVersion\"));\nexport type ProofVersion = typeof ProofVersion.Type;\nexport const ProofPurpose = BoundedId.pipe(Schema.brand(\"effect-auth/ProofPurpose\"));\nexport type ProofPurpose = typeof ProofPurpose.Type;\n\nexport const ProofInstant = Schema.Int.check(\n  Schema.isBetween({ minimum: -8640000000000000, maximum: 8640000000000000 }),\n);\n\nconst BoundedIdentifier = Schema.Struct({\n  namespace: LoginIdentifier.fields.namespace.check(Schema.isMaxLength(256)),\n  value: LoginIdentifier.fields.value.check(Schema.isMaxLength(2048)),\n}).pipe(Schema.decodeTo(LoginIdentifier));\n\nconst BoundedRevision = Schema.Struct({\n  ...AuthenticationRevision.fields,\n  subjectId: AuthenticationRevision.fields.subjectId.check(Schema.isMaxLength(256)),\n  securityRevision: AuthenticationRevision.fields.securityRevision.check(Schema.isMaxLength(256)),\n  credentials: Schema.Array(\n    Schema.Struct({\n      credentialId: CredentialRevision.fields.credentialId.check(Schema.isMaxLength(256)),\n      revision: CredentialRevision.fields.revision.check(Schema.isMaxLength(256)),\n    }),\n  ).check(Schema.isMaxLength(32)),\n});\n\nconst FlowBinding = {\n  flowId: BoundedId,\n  contextDigest: TokenDigest.check(Schema.isMaxLength(256)),\n};\n\nexport const IdentifierProofBinding = Schema.TaggedStruct(\"Identifier\", {\n  ...FlowBinding,\n  identifier: BoundedIdentifier,\n});\n\nexport const SubjectProofBinding = Schema.TaggedStruct(\"Subject\", {\n  ...FlowBinding,\n  revision: BoundedRevision,\n  identifier: BoundedIdentifier,\n});\n\nexport const IdentifierChangeProofBinding = Schema.TaggedStruct(\"IdentifierChange\", {\n  ...FlowBinding,\n  revision: BoundedRevision,\n  identifier: BoundedIdentifier,\n});\n\nexport const ProofBinding = Schema.Union([\n  IdentifierProofBinding,\n  SubjectProofBinding,\n  IdentifierChangeProofBinding,\n]);\n\nexport type ProofBinding = typeof ProofBinding.Type;\n\n/** Same public shape for issued, duplicate, ineligible, and throttled requests. */\nexport const ProofReference = Schema.Struct({\n  proofId: ProofId,\n  purpose: ProofPurpose,\n  keyId: BoundedId,\n});\n\nexport type ProofReference = typeof ProofReference.Type;\n\nexport const ProofRequestReceipt = Schema.Struct({\n  requestId: ProofRequestId,\n  reference: ProofReference,\n});\n\nexport type ProofRequestReceipt = typeof ProofRequestReceipt.Type;\n\nexport const ProofContinuation = Schema.Struct({\n  continuationId: ProofContinuationId,\n  purpose: ProofPurpose,\n  expiresAtMillis: ProofInstant,\n});\n\nexport type ProofContinuation = typeof ProofContinuation.Type;\n\nexport const ProofAttemptDecision = Schema.Union([\n  Schema.TaggedStruct(\"Accepted\", { continuation: ProofContinuation }),\n  Schema.TaggedStruct(\"Rejected\", {}),\n]);\n\nexport type ProofAttemptDecision = typeof ProofAttemptDecision.Type;\nexport const ProofCompletionDecision = Schema.Literals([\"completed\", \"rejected\"]);\nexport type ProofCompletionDecision = typeof ProofCompletionDecision.Type;\n\nexport const ProofDeliveryOutcome = Schema.Union([\n  Schema.TaggedStruct(\"Accepted\", {}),\n  Schema.TaggedStruct(\"DefiniteFailure\", {\n    reason: Schema.Literals([\"recipient\", \"policy\", \"unavailable\"]),\n  }),\n  Schema.TaggedStruct(\"Ambiguous\", {}),\n]);\n\nexport type ProofDeliveryOutcome = typeof ProofDeliveryOutcome.Type;\n\nexport const ProofDeliveryStatus = Schema.Literals([\n  \"accepted\",\n  \"failed\",\n  \"ambiguous\",\n  \"unavailable\",\n  \"not-dispatched\",\n]);\n\nexport type ProofDeliveryStatus = typeof ProofDeliveryStatus.Type;\n\nexport const ProofCleanupResult = Schema.Struct({\n  removed: Schema.Natural,\n  hasMore: Schema.Boolean,\n});\n\nexport type ProofCleanupResult = typeof ProofCleanupResult.Type;\n"],"mappings":";;;;;AAMA,MAAM,YAAY,OAAO,OAAO,MAAM,OAAO,YAAY,CAAC,GAAG,OAAO,YAAY,GAAG,CAAC;AAEpF,MAAa,UAAU,UAAU,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAEzE,MAAa,iBAAiB,UAAU,KAAK,OAAO,MAAM,4BAA4B,CAAC;AAEvF,MAAa,kBAAkB,UAAU,KAAK,OAAO,MAAM,6BAA6B,CAAC;AAEzF,MAAa,sBAAsB,UAAU,KAAK,OAAO,MAAM,iCAAiC,CAAC;AAEjG,MAAa,eAAe,UAAU,KAAK,OAAO,MAAM,0BAA0B,CAAC;AAEnF,MAAa,eAAe,UAAU,KAAK,OAAO,MAAM,0BAA0B,CAAC;AAGnF,MAAa,eAAe,OAAO,IAAI,MACrC,OAAO,UAAU;CAAE,SAAS;CAAmB,SAAS;AAAiB,CAAC,CAC5E;AAEA,MAAM,oBAAoB,OAAO,OAAO;CACtC,WAAW,gBAAgB,OAAO,UAAU,MAAM,OAAO,YAAY,GAAG,CAAC;CACzE,OAAO,gBAAgB,OAAO,MAAM,MAAM,OAAO,YAAY,IAAI,CAAC;AACpE,CAAC,CAAC,CAAC,KAAK,OAAO,SAAS,eAAe,CAAC;AAExC,MAAM,kBAAkB,OAAO,OAAO;CACpC,GAAG,uBAAuB;CAC1B,WAAW,uBAAuB,OAAO,UAAU,MAAM,OAAO,YAAY,GAAG,CAAC;CAChF,kBAAkB,uBAAuB,OAAO,iBAAiB,MAAM,OAAO,YAAY,GAAG,CAAC;CAC9F,aAAa,OAAO,MAClB,OAAO,OAAO;EACZ,cAAc,mBAAmB,OAAO,aAAa,MAAM,OAAO,YAAY,GAAG,CAAC;EAClF,UAAU,mBAAmB,OAAO,SAAS,MAAM,OAAO,YAAY,GAAG,CAAC;CAC5E,CAAC,CACH,CAAC,CAAC,MAAM,OAAO,YAAY,EAAE,CAAC;AAChC,CAAC;AAED,MAAM,cAAc;CAClB,QAAQ;CACR,eAAe,YAAY,MAAM,OAAO,YAAY,GAAG,CAAC;AAC1D;AAEA,MAAa,yBAAyB,OAAO,aAAa,cAAc;CACtE,GAAG;CACH,YAAY;AACd,CAAC;AAED,MAAa,sBAAsB,OAAO,aAAa,WAAW;CAChE,GAAG;CACH,UAAU;CACV,YAAY;AACd,CAAC;AAED,MAAa,+BAA+B,OAAO,aAAa,oBAAoB;CAClF,GAAG;CACH,UAAU;CACV,YAAY;AACd,CAAC;AAED,MAAa,eAAe,OAAO,MAAM;CACvC;CACA;CACA;AACF,CAAC;;AAKD,MAAa,iBAAiB,OAAO,OAAO;CAC1C,SAAS;CACT,SAAS;CACT,OAAO;AACT,CAAC;AAID,MAAa,sBAAsB,OAAO,OAAO;CAC/C,WAAW;CACX,WAAW;AACb,CAAC;AAID,MAAa,oBAAoB,OAAO,OAAO;CAC7C,gBAAgB;CAChB,SAAS;CACT,iBAAiB;AACnB,CAAC;AAID,MAAa,uBAAuB,OAAO,MAAM,CAC/C,OAAO,aAAa,YAAY,EAAE,cAAc,kBAAkB,CAAC,GACnE,OAAO,aAAa,YAAY,CAAC,CAAC,CACpC,CAAC;AAGD,MAAa,0BAA0B,OAAO,SAAS,CAAC,aAAa,UAAU,CAAC;AAGhF,MAAa,uBAAuB,OAAO,MAAM;CAC/C,OAAO,aAAa,YAAY,CAAC,CAAC;CAClC,OAAO,aAAa,mBAAmB,EACrC,QAAQ,OAAO,SAAS;EAAC;EAAa;EAAU;CAAa,CAAC,EAChE,CAAC;CACD,OAAO,aAAa,aAAa,CAAC,CAAC;AACrC,CAAC;AAID,MAAa,sBAAsB,OAAO,SAAS;CACjD;CACA;CACA;CACA;CACA;AACF,CAAC;AAID,MAAa,qBAAqB,OAAO,OAAO;CAC9C,SAAS,OAAO;CAChB,SAAS,OAAO;AAClB,CAAC"}

package/dist/proofs/module.d.mts

@@ -0,0 +1,344 @@
+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 "../Auth.mjs";
+import { ProofBinding, ProofCleanupResult, ProofCompletionDecision, ProofId, ProofPurpose } from "./models.mjs";
+import { ProofCapabilityUnsupported, ProofConfigurationError, ProofIngressDenied, ProofInvalid, ProofRequestConflict, ProofUnavailable } from "./errors.mjs";
+import { EmailProofDelivery } from "./EmailProofDelivery.mjs";
+import { ProofPolicy } from "./policy.mjs";
+import { ProofPersistence } from "./ProofPersistence.mjs";
+import { PreparedProofDispatch, ProofIssuePlan } from "./dispatch.mjs";
+import { ProofCompletionPlan } from "./completion.mjs";
+import { ProofKeyring, ProofSecretPolicy } from "./crypto.mjs";
+import { SmsProofDelivery } from "./SmsProofDelivery.mjs";
+import { Context, Effect, Layer, Redacted, Schema, Types } from "effect";
+//#region src/proofs/module.d.ts
+interface ProofModule<Id extends string, Binding> {
+  readonly moduleId: Id;
+  readonly _tag: "effect-auth/ProofModule";
+  readonly binding: Types.Invariant<Binding>;
+}
+/** Each module has one fixed purpose and a schema that makes required binding fields mandatory.
+ * Consumer codec extensions are not implicit authority: bind every extra relevant
+ * field into contextDigest. Canonical proof bytes include only the declared core binding.
+ */
+declare const makeProofModule: <const Id extends string, Binding extends Schema.Codec<ProofBinding, unknown, unknown, unknown>>(moduleId: Id, input: {
+  readonly purpose: ProofPurpose;
+  readonly binding: Binding;
+  readonly channel: "email" | "sms";
+  readonly template: string;
+  readonly secret: ProofSecretPolicy;
+  readonly policy: ProofPolicy;
+  readonly keys?: ProofKeyring;
+}) => Readonly<{
+  Proofs: Context.Service<ProofModule<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;
+    }) => 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;
+    }) => 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: Redacted.Redacted<string>;
+    }) => 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>;
+    readonly planComplete: (input: {
+      readonly continuationId: string & import("effect/Brand").Brand<"effect-auth/ProofContinuationId">;
+      readonly binding: Binding["Type"];
+      readonly credential: Redacted.Redacted<string>;
+    }) => 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: Redacted.Redacted<string>;
+    }) => Effect.Effect<PreparedCommit<ProofCompletionDecision>, HookDenied | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable>;
+    readonly cancel: (binding: Binding["Type"]) => Effect.Effect<PreparedCommit<void>, HookDenied | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable>;
+    readonly cleanup: (limit: number) => Effect.Effect<PreparedCommit<ProofCleanupResult>, HookDenied | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable>;
+  }>;
+  emailLayer: Layer.Layer<ProofModule<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: Layer.Layer<ProofModule<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: Layer.Layer<OperationHandler<`${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: 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<`${Id}/cancel`, {
+    readonly binding: Binding["Type"];
+  }, void, AssuranceRequired | AuthenticationRequired | HookDenied | InvalidOperationInput | OperationForbidden | OperationPrivateOutputUnsupported | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable> | OperationHandler<`${Id}/cleanup`, {
+    readonly limit: number;
+  }, {
+    readonly removed: number;
+    readonly hasMore: boolean;
+  }, AssuranceRequired | AuthenticationRequired | HookDenied | InvalidOperationInput | OperationForbidden | OperationPrivateOutputUnsupported | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable> | OperationHandler<`${Id}/complete`, {
+    readonly continuationId: string & import("effect/Brand").Brand<"effect-auth/ProofContinuationId">;
+    readonly binding: Binding["Type"];
+    readonly credential: Redacted.Redacted<string>;
+  }, void, AssuranceRequired | AuthenticationRequired | HookDenied | InvalidOperationInput | OperationForbidden | OperationPrivateOutputUnsupported | ProofCapabilityUnsupported | ProofIngressDenied | ProofInvalid | ProofRequestConflict | ProofUnavailable> | OperationHandler<`${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<`${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<Id, Binding["Type"]>>;
+  operations: {
+    Request: AuthOperation<`${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<`${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<`${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<`${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<`${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<`${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<`${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<`${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<`${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<`${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<`${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<`${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>>;
+}>;
+//#endregion
+export { ProofModule, makeProofModule };
+//# sourceMappingURL=module.d.mts.map