@pax2pay/model-banking 0.1.452 → 0.1.454

package/Card/Operation/index.ts

@@ -16,23 +16,15 @@ export namespace Operation {
 			created: isoly.DateTime.now(),
 		}
 	}
-	export function fromEntry(entry: Entry): Operation | undefined {
-		return entry.type == "unknown"
+	export function fromEntry(entry: Entry | Entry.Failed): Operation | undefined {
+		return entry.status == "failed"
 			? undefined
 			: {
 					type: "authorization",
-					id: (entry.type != "refund" ? entry.authorization?.id : entry.transaction?.id) ?? "unknown",
-					status: Operation.fromEntryStatus(entry.type),
+					id: entry.transaction ?? "unknown",
+					status: entry.type == "capture" ? "captured" : "refunded",
 					created: isoly.DateTime.now(),
 			  }
 	}
-	export function fromEntryStatus(status: Exclude<Entry.Type, "unknown">): OperationAuthorization.Status {
-		const statusConverter: Record<Exclude<Entry.Type, "unknown">, OperationAuthorization.Status> = {
-			capture: "captured",
-			cancel: "cancelled",
-			refund: "refunded",
-		}
-		return statusConverter[status]
-	}
 	export const type = isly.union(Card.type, OperationAuthorization.type)
 }

package/Client/Transactions/index.ts

@@ -42,7 +42,7 @@ export class Transactions extends rest.Collection<gracely.Error> {
 		)
 	}
 	async getOperations(transactionId: string): Promise<Operation[] | gracely.Error> {
-		return this.client.get<Operation[]>(`/transaction/${transactionId}/operations`)
+		return this.client.get<Operation[]>(`/transaction/${transactionId}/operation`)
 	}
 	async statistics(
 		range: isoly.DateRange,

package/Operation/Changes.ts

@@ -114,7 +114,7 @@ export namespace Changes {
 	}
 	export function fromRefund(
 		settlement: string | undefined, // FIXME: remove | undefined when we're sure we send the id
-		refund: Settlement.Entry.Refund.Creatable,
+		refund: Settlement.Entry.Creatable.Refund,
 		charge: number | undefined,
 		sum: Sum
 	): Changes {

package/Operation/Creatable.ts

@@ -36,7 +36,7 @@ export namespace Creatable {
 		changes: Changes.type,
 		type: isly.string(types),
 	})
-	export function fromRefund(account: string, settlement: string, entry: Settlement.Entry.Refund.Creatable): Creatable {
+	export function fromRefund(account: string, settlement: string, entry: Settlement.Entry.Creatable.Refund): Creatable {
 		// The Entry.Refund.Creatable has negative amount and fee
 		// The operation amounts should always be positive
 		const [currency, entryAmount] = entry.amount

package/Settlement/Entry/Creatable.ts

@@ -1,15 +1,115 @@
 import { isly } from "isly"
-import { Cancel as EntryCancel } from "./Cancel"
-import { Capture as EntryCapture } from "./Capture"
-import { Refund as EntryRefund } from "./Refund"
-import { Unknown as EntryUnknown } from "./Unknown"
+import { Acquirer } from "../../Acquirer"
+import { Amount } from "../../Amount"
+import { Merchant } from "../../Merchant"
+import { Batch } from "../Batch"
+import { Fee } from "../Fee"
+import { Identifier as SettlementIdentifier } from "../Identifier"
+import { Entry as LegacyEntry } from "./Legacy"
 
-export type Creatable = EntryCancel.Creatable | EntryCapture.Creatable | EntryRefund.Creatable | EntryUnknown.Creatable
+export type Creatable = Creatable.Known | Creatable.Unknown
 export namespace Creatable {
-	export const type = isly.union(
-		EntryCancel.Creatable.type,
-		EntryCapture.Creatable.type,
-		EntryRefund.Creatable.type,
-		EntryUnknown.Creatable.type
-	)
+	export interface Base {
+		card: string
+		transaction?: string
+		account: string
+		approvalCode: string
+		merchant: Merchant
+		acquirer: Acquirer
+		reference: string
+		batch: Batch
+		fee: Fee
+		amount: Amount
+		settlement: SettlementIdentifier
+	}
+	export namespace Base {
+		export const type = isly.object<Base>({
+			card: isly.string(),
+			transaction: isly.string().optional(),
+			account: isly.string(),
+			approvalCode: isly.string(),
+			merchant: Merchant.type,
+			acquirer: Acquirer.type,
+			reference: isly.string(),
+			batch: Batch.type,
+			fee: Fee.type,
+			amount: Amount.type,
+			settlement: SettlementIdentifier.type,
+		})
+	}
+	export interface Capture extends Base {
+		type: "capture"
+	}
+	export namespace Capture {
+		export const type = Base.type.extend<Capture>({
+			type: isly.string("capture"),
+		})
+		export function fromLegacy(maybeLegacy: Capture | LegacyEntry.Capture.Creatable): Capture {
+			return type.is(maybeLegacy)
+				? maybeLegacy
+				: {
+						type: maybeLegacy.type,
+						card: maybeLegacy.authorization.card.id,
+						transaction: maybeLegacy.authorization.transaction?.id,
+						account: maybeLegacy.authorization.account || "unknown",
+						approvalCode: maybeLegacy.authorization.approvalCode ?? "unknown",
+						merchant: maybeLegacy.authorization.merchant,
+						acquirer: maybeLegacy.authorization.acquirer,
+						reference: maybeLegacy.reference,
+						batch: maybeLegacy.batch,
+						fee: maybeLegacy.fee,
+						amount: maybeLegacy.amount,
+						settlement: maybeLegacy.settlement ?? "unknown",
+				  }
+		}
+	}
+	export interface Refund extends Base {
+		type: "refund"
+	}
+	export namespace Refund {
+		export const type = Base.type.extend<Refund>({
+			type: isly.string("refund"),
+		})
+		export function fromLegacy(maybeLegacy: Refund | LegacyEntry.Refund.Creatable): Refund {
+			return type.is(maybeLegacy)
+				? maybeLegacy
+				: {
+						type: maybeLegacy.type,
+						card: maybeLegacy.card,
+						account: maybeLegacy.account ?? "unknown",
+						approvalCode: maybeLegacy.authorization.approvalCode ?? "unknown",
+						merchant: maybeLegacy.merchant,
+						acquirer: maybeLegacy.acquirer,
+						reference: maybeLegacy.reference,
+						batch: maybeLegacy.batch,
+						fee: maybeLegacy.fee,
+						amount: maybeLegacy.amount,
+						settlement: maybeLegacy.settlement ?? "unknown",
+				  }
+		}
+	}
+	export type Known = Capture | Refund
+
+	export namespace Known {
+		export const type = isly.union(Capture.type, Refund.type)
+		export function fromLegacy(
+			maybeLegacy: Creatable.Known | LegacyEntry.Capture.Creatable | LegacyEntry.Refund.Creatable
+		): Creatable.Known {
+			return maybeLegacy.type == "capture" ? Capture.fromLegacy(maybeLegacy) : Refund.fromLegacy(maybeLegacy)
+		}
+	}
+	export interface Unknown extends Partial<Base> {
+		type: "unknown"
+		data: Record<string, unknown>
+	}
+	export namespace Unknown {
+		export const type = isly.object<Unknown>({
+			...(Object.fromEntries(
+				Object.entries(Base.type.getProperties()).map(([k, v]) => [k, v.optional()])
+			) as isly.object.Properties<Partial<Base>>), // TODO: Add "Partial" to isly
+			type: isly.string("unknown"),
+			data: isly.record<Record<string, unknown>>(isly.string(), isly.any()),
+		})
+	}
+	export const type = isly.union(Known.type, Unknown.type)
 }

package/Settlement/Entry/Failed.ts

@@ -0,0 +1,27 @@
+import { isoly } from "isoly"
+import { isly } from "isly"
+import { Creatable } from "./Creatable"
+
+export type Failed = Creatable & {
+	status: "failed"
+	reason: string
+	created: isoly.DateTime
+}
+export namespace Failed {
+	export const type = isly.intersection<
+		Failed,
+		Creatable,
+		{
+			status: "failed"
+			reason: string
+			created: isoly.DateTime
+		}
+	>(
+		Creatable.type,
+		isly.object({
+			status: isly.string<"failed">("failed"),
+			reason: isly.string(),
+			created: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
+		})
+	)
+}

package/Settlement/Entry/{Cancel.ts → Legacy/Cancel.ts}

@@ -1,10 +1,10 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { Amount } from "../../Amount"
-import { Authorization } from "../../Authorization"
-import { Identifier as SettlementIdentifier } from "../../Settlement/Identifier"
-import { Batch } from "../Batch"
-import { Fee } from "../Fee"
+import { Amount } from "../../../Amount"
+import { Authorization } from "../../../Authorization"
+import { Batch } from "../../Batch"
+import { Fee } from "../../Fee"
+import { Identifier as SettlementIdentifier } from "../../Identifier"
 
 export interface Cancel extends Omit<Cancel.Creatable, "settlement"> {
 	status: "succeeded" | "failed"

package/Settlement/Entry/{Capture.ts → Legacy/Capture.ts}

@@ -1,10 +1,10 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { Amount } from "../../Amount"
-import { Authorization } from "../../Authorization"
-import { Identifier as SettlementIdentifier } from "../../Settlement/Identifier"
-import { Batch } from "../Batch"
-import { Fee } from "../Fee"
+import { Amount } from "../../../Amount"
+import { Authorization } from "../../../Authorization"
+import { Batch } from "../../Batch"
+import { Fee } from "../../Fee"
+import { Identifier as SettlementIdentifier } from "../../Identifier"
 
 export interface Capture extends Omit<Capture.Creatable, "settlement"> {
 	status: "succeeded" | "failed"

package/Settlement/Entry/Legacy/Creatable.ts

@@ -0,0 +1,15 @@
+import { isly } from "isly"
+import { Cancel as EntryCancel } from "./Cancel"
+import { Capture as EntryCapture } from "./Capture"
+import { Refund as EntryRefund } from "./Refund"
+import { Unknown as EntryUnknown } from "./Unknown"
+
+export type Creatable = EntryCancel.Creatable | EntryCapture.Creatable | EntryRefund.Creatable | EntryUnknown.Creatable
+export namespace Creatable {
+	export const type = isly.union(
+		EntryCancel.Creatable.type,
+		EntryCapture.Creatable.type,
+		EntryRefund.Creatable.type,
+		EntryUnknown.Creatable.type
+	)
+}

package/Settlement/Entry/{Refund.ts → Legacy/Refund.ts}

@@ -1,13 +1,13 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { Acquirer } from "../../Acquirer"
-import { Amount } from "../../Amount"
-import { Authorization } from "../../Authorization"
-import { Merchant } from "../../Merchant"
-import { Identifier as SettlementIdentifier } from "../../Settlement/Identifier"
-import { Transaction } from "../../Transaction"
-import { Batch } from "../Batch"
-import { Fee } from "../Fee"
+import { Acquirer } from "../../../Acquirer"
+import { Amount } from "../../../Amount"
+import { Authorization } from "../../../Authorization"
+import { Merchant } from "../../../Merchant"
+import { Transaction } from "../../../Transaction"
+import { Batch } from "../../Batch"
+import { Fee } from "../../Fee"
+import { Identifier as SettlementIdentifier } from "../../Identifier"
 
 export interface Refund extends Omit<Refund.Creatable, "settlement"> {
 	status: "succeeded" | "failed"

package/Settlement/Entry/{Unknown.ts → Legacy/Unknown.ts}

@@ -1,8 +1,8 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
-import { Authorization } from "../../Authorization"
-import { Identifier as SettlementIdentifier } from "../../Settlement/Identifier"
-import { Batch } from "../Batch"
+import { Authorization } from "../../../Authorization"
+import { Batch } from "../../Batch"
+import { Identifier as SettlementIdentifier } from "../../Identifier"
 
 export interface Unknown extends Omit<Unknown.Creatable, "settlement"> {
 	status: "succeeded" | "failed"

package/Settlement/Entry/Legacy/index.ts

@@ -0,0 +1,55 @@
+import { gracely } from "gracely"
+import { isoly } from "isoly"
+import { isly } from "isly"
+import { Transaction } from "../../../Transaction"
+import { Cancel as EntryCancel } from "./Cancel"
+import { Capture as EntryCapture } from "./Capture"
+import { Creatable as EntryCreatable } from "./Creatable"
+import { Refund as EntryRefund } from "./Refund"
+import { Unknown as EntryUnknown } from "./Unknown"
+
+export type Entry = Entry.Cancel | Entry.Capture | Entry.Refund | Entry.Unknown
+export namespace Entry {
+	export import Cancel = EntryCancel
+	export import Capture = EntryCapture
+	export import Refund = EntryRefund
+	export import Unknown = EntryUnknown
+	export type Type = "unknown" | "refund" | "capture" | "cancel"
+	export import Creatable = EntryCreatable
+	export function from(creatable: Entry.Creatable, transaction: Transaction | gracely.Error | string): Entry {
+		let result: Entry
+		const created = isoly.DateTime.now()
+		if (!Transaction.type.is(transaction) || transaction.status != "finalized")
+			result = { status: "failed", reason: reason(creatable, transaction), ...creatable, created }
+		else
+			switch (creatable.type) {
+				case "capture":
+					result = Capture.from(creatable)
+					break
+				case "refund":
+					result = Refund.from(creatable, transaction)
+					break
+				default:
+					result = { ...creatable, status: "failed", reason: "Entry type not implemented yet.", created }
+					break
+			}
+		return result
+	}
+	function reason(creatable: Entry.Creatable, transaction: Transaction | gracely.Error | string): string {
+		const result: string[] = []
+		!creatable.authorization && result.push("Missing authorization.")
+		if (gracely.Error.is(transaction))
+			result.push(`gracely error: ${JSON.stringify(transaction)}`)
+		else if (typeof transaction != "string")
+			result.push(`Transaction ${transaction.id} on account ${transaction.accountId} unable to be finalized.`)
+		else
+			result.push(transaction || "No reason provided")
+		return result.join("\n")
+	}
+	export const type = isly.union<Entry, Entry.Cancel, Entry.Capture, Entry.Refund, Entry.Unknown>(
+		Entry.Cancel.type,
+		Entry.Capture.type,
+		Entry.Refund.type,
+		Entry.Unknown.type
+	)
+}

package/Settlement/Entry/Succeeded.ts

@@ -0,0 +1,22 @@
+import { isoly } from "isoly"
+import { isly } from "isly"
+import { Rail } from "../../Rail"
+import { Creatable } from "./Creatable"
+
+export interface Succeeded extends Omit<Creatable.Known, "transaction" | "card"> {
+	status: "succeeded"
+	card: Rail.Address.Card
+	transaction: string
+	created: isoly.DateTime
+}
+export namespace Succeeded {
+	export const type = Creatable.Base.type
+		.omit<"transaction" | "card">(["card", "transaction"])
+		.extend<Succeeded & { type: "capture" | "refund" }>({
+			type: isly.string(["capture", "refund"]),
+			status: isly.string<"succeeded">("succeeded"),
+			card: Rail.Address.Card.type,
+			transaction: isly.string(),
+			created: isly.fromIs("isoly.DateTime", isoly.DateTime.is),
+		})
+}

package/Settlement/Entry/fromCreatable.ts

@@ -0,0 +1,38 @@
+import { gracely } from "gracely"
+import { isoly } from "isoly"
+import { Card } from "../../Card"
+import { Rail } from "../../Rail"
+import { Transaction } from "../../Transaction"
+import type { Entry } from "."
+import { Creatable } from "./Creatable"
+
+export function fromCreatable(
+	creatable: Creatable,
+	transaction: Transaction.CardTransaction | gracely.Error | string,
+	card?: Card
+): Entry {
+	let result: Entry
+	const reasons: string[] = []
+	const created = isoly.DateTime.now()
+	if (creatable.type == "unknown")
+		reasons.push("Unknown entry type.")
+	if (gracely.Error.is(transaction))
+		reasons.push(`gracely error: ${JSON.stringify(transaction)}`)
+	else if (typeof transaction == "string")
+		reasons.push(transaction || "No reason provided.")
+	else if (transaction.status != "finalized")
+		reasons.push(`Transaction ${transaction.id} on account ${transaction.accountId} unable to be finalized.`)
+	if (reasons.length > 0)
+		result = { status: "failed", reason: reasons.join("\n"), ...creatable, created }
+	else if (!card)
+		result = { status: "failed", reason: "Missing card", ...creatable, created }
+	else
+		result = {
+			status: "succeeded",
+			...(creatable as Creatable.Known),
+			created,
+			card: Rail.Address.Card.from(card),
+			transaction: (transaction as Transaction.CardTransaction).id,
+		}
+	return result
+}

package/Settlement/Entry/fromLegacy.ts

@@ -0,0 +1,86 @@
+import { isoly } from "isoly"
+import { Card } from "../../Card"
+import { Rail } from "../../Rail"
+import { Identifier as SettlementIdentifier } from "../Identifier"
+import type { Entry } from "."
+import type { Failed } from "./Failed"
+import { Entry as LegacyEntry } from "./Legacy"
+import { type } from "./type"
+
+function toFailed(legacy: LegacyEntry.Unknown | LegacyEntry.Cancel): Failed {
+	return {
+		type: "unknown",
+		status: "failed",
+		data: legacy.type == "cancel" ? legacy : legacy.data,
+		reason: legacy.reason ?? "unknown",
+		created: legacy.created ?? isoly.DateTime.now(),
+		settlement: legacy.settlement ?? "unknown",
+		reference: ("reference" in legacy && legacy.reference) || "unknown",
+		batch: legacy.batch,
+		...("authorization" in legacy &&
+			legacy.authorization && {
+				account: legacy.authorization.account ?? "unknown",
+				approvalCode: legacy.authorization.approvalCode,
+				merchant: legacy.authorization.merchant,
+				acquirer: legacy.authorization.acquirer,
+				card: legacy.authorization.card.id,
+				transaction: legacy.authorization.transaction?.id,
+			}),
+		...("fee" in legacy && { fee: legacy.fee }),
+		...("amount" in legacy && { amount: legacy.amount }),
+	}
+}
+function toEntry(legacy: LegacyEntry.Capture | LegacyEntry.Refund, card?: Rail.Address.Card): Entry {
+	return {
+		type: legacy.type,
+		created: legacy.created ?? isoly.DateTime.now(),
+		...(legacy.status == "failed"
+			? {
+					card: legacy.type == "refund" ? legacy.card : legacy.authorization.card.id,
+					status: "failed",
+					reason: legacy.reason ?? "unknown",
+			  }
+			: {
+					card: card ?? {
+						type: "card",
+						scheme: (stack => (stack ? Card.Stack.toScheme(stack) : "unknown"))(
+							legacy.settlement && SettlementIdentifier.toProcessor(legacy.settlement)
+						) as Card.Scheme,
+						...(legacy.type == "refund"
+							? { id: legacy.card, iin: "unknown", last4: "unknown" }
+							: {
+									id: legacy.authorization.card.id,
+									iin: legacy.authorization.card.iin ?? "unknown",
+									last4: legacy.authorization.card.last4 ?? "unknown",
+							  }),
+						expiry: [0, 0] as unknown as Card.Expiry,
+						holder: "unknown",
+					},
+					status: "succeeded",
+			  }),
+		transaction:
+			("transaction" in legacy
+				? legacy.transaction?.id
+				: "authorization" in legacy && "transaction" in legacy.authorization
+				? legacy.authorization.transaction?.id
+				: "unknown") ?? "unknown",
+		account: legacy.account ?? (("transaction" in legacy && legacy.transaction?.accountId) || "unknown"),
+		approvalCode: legacy.authorization.approvalCode ?? "unknown",
+		...(legacy.type == "refund"
+			? { merchant: legacy.merchant, acquirer: legacy.acquirer }
+			: { merchant: legacy.authorization.merchant, acquirer: legacy.authorization.acquirer }),
+		reference: legacy.reference,
+		batch: legacy.batch,
+		fee: legacy.fee,
+		amount: legacy.amount,
+		settlement: legacy.settlement ?? "unknown",
+	}
+}
+
+export function fromLegacy(maybeLegacy: LegacyEntry | Entry): Entry {
+	return type.is(maybeLegacy)
+		? maybeLegacy
+		: maybeLegacy.type == "cancel" || maybeLegacy.type == "unknown"
+		? toFailed(maybeLegacy)
+		: toEntry(maybeLegacy)
+}

package/Settlement/Entry/index.ts

@@ -1,57 +1,26 @@
-import { gracely } from "gracely"
-import { isoly } from "isoly"
-import { isly } from "isly"
-import { Transaction } from "../../Transaction"
-import { Cancel as EntryCancel } from "./Cancel"
-import { Capture as EntryCapture } from "./Capture"
 import { Creatable as EntryCreatable } from "./Creatable"
-import { Refund as EntryRefund } from "./Refund"
+import { Failed as EntryFailed } from "./Failed"
+import { fromCreatable } from "./fromCreatable"
+import { fromLegacy as entryFromLegacy } from "./fromLegacy"
+import { Entry as LegacyEntry } from "./Legacy"
+import { Succeeded as EntrySucceeded } from "./Succeeded"
 import { Summary as EntrySummary } from "./Summary"
-import { Unknown as EntryUnknown } from "./Unknown"
+import { type as entryType } from "./type"
 
-export type Entry = Entry.Cancel | Entry.Capture | Entry.Refund | Entry.Unknown
+export type Entry = EntrySucceeded | EntryFailed
 export namespace Entry {
-	export import Cancel = EntryCancel
-	export import Capture = EntryCapture
-	export import Refund = EntryRefund
-	export import Unknown = EntryUnknown
-	export type Type = "unknown" | "refund" | "capture" | "cancel"
-	export import Summary = EntrySummary
-	export import Creatable = EntryCreatable
-	export function from(creatable: Entry.Creatable, transaction: Transaction | gracely.Error | string): Entry {
-		let result: Entry
-		const created = isoly.DateTime.now()
-		if (!Transaction.type.is(transaction) || transaction.status != "finalized")
-			result = { status: "failed", reason: reason(creatable, transaction), ...creatable, created }
-		else
-			switch (creatable.type) {
-				case "capture":
-					result = Capture.from(creatable)
-					break
-				case "refund":
-					result = Refund.from(creatable, transaction)
-					break
-				default:
-					result = { ...creatable, status: "failed", reason: "Entry type not implemented yet.", created }
-					break
-			}
-		return result
+	export interface Capture extends EntrySucceeded {
+		type: "capture"
 	}
-	function reason(creatable: Entry.Creatable, transaction: Transaction | gracely.Error | string): string {
-		const result = []
-		!creatable.authorization && result.push("Missing authorization.")
-		if (gracely.Error.is(transaction))
-			result.push(`gracely error: ${JSON.stringify(transaction)}`)
-		else if (typeof transaction != "string")
-			result.push(`Transaction ${transaction.id} on account ${transaction.accountId} unable to be finalized.`)
-		else
-			result.push(transaction || "No reason provided")
-		return result.join("\n")
+	export interface Refund extends EntrySucceeded {
+		type: "refund"
 	}
-	export const type = isly.union<Entry, Entry.Cancel, Entry.Capture, Entry.Refund, Entry.Unknown>(
-		Entry.Cancel.type,
-		Entry.Capture.type,
-		Entry.Refund.type,
-		Entry.Unknown.type
-	)
+	export import Creatable = EntryCreatable
+	export import Failed = EntryFailed
+	export import Succeeded = EntrySucceeded
+	export import Summary = EntrySummary
+	export import Legacy = LegacyEntry
+	export const type = entryType
+	export const fromLegacy = entryFromLegacy
+	export const from = fromCreatable
 }

package/Settlement/Entry/type.ts

@@ -0,0 +1,6 @@
+import { isly } from "isly"
+import type { Entry } from "."
+import { Failed } from "./Failed"
+import { Succeeded } from "./Succeeded"
+
+export const type = isly.union<Entry, Succeeded, Failed>(Succeeded.type, Failed.type)

package/Settlement/index.ts

@@ -40,7 +40,7 @@ export namespace Settlement {
 			entries: { count: 0 },
 		}
 	}
-	export function compile(settlement: Settlement, entries: Settlement.Entry[]): Settlement {
+	export function compile(settlement: Settlement, entries: (Settlement.Entry | Settlement.Entry.Failed)[]): Settlement {
 		const result = { ...settlement }
 		for (const entry of entries) {
 			switch (entry.status) {

package/Transaction/Incoming.ts

@@ -26,7 +26,7 @@ export namespace Incoming {
 		reference: TransactionReference.type.optional(),
 	})
 
-	export function fromRefund(entry: Settlement.Entry.Refund.Creatable, card: Rail.Address.Card): Incoming {
+	export function fromRefund(entry: Settlement.Entry.Creatable.Refund, card: Rail.Address.Card): Incoming {
 		const [currency, amount] = entry.amount
 		return {
 			account: card,

package/Transaction/index.ts

@@ -335,7 +335,7 @@ export namespace Transaction {
 		}
 	}
 	export function fromRefund(
-		refund: Settlement.Entry.Refund.Creatable,
+		refund: Settlement.Entry.Creatable.Refund,
 		id: string,
 		account: { id: string; name: string; organization: string },
 		card: Rail.Address.Card,

package/Warning/Settlement/UnknownEntry.ts

@@ -2,14 +2,16 @@ import { cryptly } from "cryptly"
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Authorization } from "../../Authorization"
-import { Unknown } from "../../Settlement/Entry/Unknown"
+import { Entry } from "../../Settlement/Entry"
 import { Identifier } from "../../Settlement/Identifier"
+import { Transaction } from "../../Transaction"
 import { Base } from "../Base"
 
 export interface UnknownEntry extends Base {
 	type: "unknown-entry"
 	resource: Identifier
 	authorization?: Authorization["id"]
+	transaction?: Transaction["id"]
 }
 
 export namespace UnknownEntry {
@@ -17,12 +19,13 @@ export namespace UnknownEntry {
 		type: isly.string("unknown-entry"),
 		resource: Identifier.type,
 		authorization: isly.fromIs("Authorization.id", cryptly.Identifier.is).optional(),
+		transaction: isly.string().optional(),
 	})
-	export function create(entry: Unknown, resource: Identifier): UnknownEntry {
+	export function create(entry: Extract<Entry.Failed, { type: "unknown" }>, resource: Identifier): UnknownEntry {
 		return {
 			type: "unknown-entry",
 			resource,
-			authorization: entry.authorization?.id,
+			transaction: entry.transaction,
 			date: isoly.Date.now(),
 		}
 	}