@pax2pay/model-banking 0.1.423 → 0.1.424

package/dist/Rail/Address/Card.d.ts

@@ -18,13 +18,13 @@ interface CardCounterpart {
     acquirer: Acquirer;
 }
 declare namespace CardCounterpart {
-    const type: isly.object.ExtendableType<CardCounterpart>;
+    const type: import("isly/dist/cjs/object").IslyObject<CardCounterpart, object>;
 }
 export declare namespace Card {
     const currencies: readonly ["EUR", "GBP", "SEK", "USD"];
-    const type: isly.object.ExtendableType<Card>;
-    const is: isly.Type.IsFunction<Card>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Card, object>;
+    const is: (value: Card | any) => value is Card;
+    const flaw: (value: Card | any) => isly.Flaw;
     function from(card: ModelCard | Rule.State.Card): Card;
     const Counterpart: typeof CardCounterpart;
     type Counterpart = CardCounterpart;

package/dist/Rail/Address/Iban.d.ts

@@ -1,4 +1,3 @@
-import { isly } from "isly";
 export interface Iban {
     type: "iban";
     iban: string;
@@ -8,6 +7,6 @@ export interface Iban {
 }
 export declare namespace Iban {
     const currencies: readonly ["EUR", "GBP", "SEK", "USD"];
-    const type: isly.object.ExtendableType<Iban>;
-    const is: isly.Type.IsFunction<Iban>;
+    const type: import("isly/dist/cjs/object").IslyObject<Iban, object>;
+    const is: (value: Iban | any) => value is Iban;
 }

package/dist/Rail/Address/PaxGiro.d.ts

@@ -1,11 +1,10 @@
 import { cryptly } from "cryptly";
-import { isly } from "isly";
 export interface PaxGiro {
     type: "paxgiro";
     identifier: cryptly.Identifier;
 }
 export declare namespace PaxGiro {
     const currencies: readonly ["EUR", "GBP", "SEK", "USD"];
-    const type: isly.object.ExtendableType<PaxGiro>;
-    const is: isly.Type.IsFunction<PaxGiro>;
+    const type: import("isly/dist/cjs/object").IslyObject<PaxGiro, object>;
+    const is: (value: PaxGiro | any) => value is PaxGiro;
 }

package/dist/Rail/Address/PaxgiroCredit.d.ts

@@ -1,9 +1,8 @@
-import { isly } from "isly";
 export interface PaxgiroCredit {
     type: "paxgiro-credit";
     reference: string;
     justInTime?: boolean;
 }
 export declare namespace PaxgiroCredit {
-    const type: isly.object.ExtendableType<PaxgiroCredit>;
+    const type: import("isly/dist/cjs/object").IslyObject<PaxgiroCredit, object>;
 }

package/dist/Rail/Address/Route.d.ts

@@ -6,7 +6,7 @@ export declare namespace Route {
         id: string;
     };
     namespace Account {
-        const type: isly.object.ExtendableType<Account>;
+        const type: import("isly/dist/cjs/object").IslyObject<Account, object>;
     }
     type Service = {
         type: "service";
@@ -14,7 +14,7 @@ export declare namespace Route {
         configuration: string;
     };
     namespace Service {
-        const type: isly.object.ExtendableType<Service>;
+        const type: import("isly/dist/cjs/object").IslyObject<Service, object>;
     }
     const type: isly.Type<Route>;
     function fromLegacy(route: string | Route): Route;

package/dist/Rail/Address/Scan.d.ts

@@ -1,4 +1,3 @@
-import { isly } from "isly";
 import { Iban } from "./Iban";
 export interface Scan {
     type: "scan";
@@ -9,6 +8,6 @@ export interface Scan {
 export declare namespace Scan {
     const currencies: readonly ["GBP"];
     function fromIban(iban: Iban): Scan;
-    const type: isly.object.ExtendableType<Scan>;
-    const is: isly.Type.IsFunction<Scan>;
+    const type: import("isly/dist/cjs/object").IslyObject<Scan, object>;
+    const is: (value: Scan | any) => value is Scan;
 }

package/dist/Rail/Address/index.d.ts

@@ -17,7 +17,7 @@ export declare namespace Address {
     function stringify(Address: Address): string;
     function beautify(Address: Address): string;
     const type: isly.Type<Address>;
-    const is: isly.Type.IsFunction<Address>;
+    const is: (value: any | Address) => value is Address;
     export import PaxGiro = AddressPaxGiro;
     export import Iban = AddressIban;
     export import Scan = AddressScan;

package/dist/Rail/Address/internal.d.ts

@@ -10,8 +10,8 @@ export interface Internal {
 }
 export declare namespace Internal {
     const currencies: readonly ["EUR", "GBP", "SEK", "USD"];
-    const type: isly.object.ExtendableType<Internal>;
-    const is: isly.Type.IsFunction<Internal>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Internal, object>;
+    const is: (value: Internal | any) => value is Internal;
+    const flaw: (value: Internal | any) => isly.Flaw;
     function toLink(internal: Internal, realm: Realm): string;
 }

package/dist/Realm.d.ts

@@ -5,8 +5,8 @@ export type Realm = typeof Realm.realms[number];
 export declare namespace Realm {
     const realms: readonly ["test", "testUK", "uk", "eea", "upcheck"];
     const type: isly.Type<Realm>;
-    const is: isly.Type.IsFunction<"uk" | "test" | "testUK" | "eea" | "upcheck">;
-    const flaw: isly.Type.FlawFunction;
+    const is: (value: any | ("uk" | "test" | "testUK" | "eea" | "upcheck")) => value is "uk" | "test" | "testUK" | "eea" | "upcheck";
+    const flaw: (value: ("uk" | "test" | "testUK" | "eea" | "upcheck") | any) => isly.Flaw;
     function toString(): string;
     const currency: Record<Realm, isoly.Currency>;
     const suppliers: Record<Realm, modelSupplier[]>;

package/dist/Rule/Base.d.ts

@@ -21,5 +21,5 @@ export declare namespace Base {
         const values: readonly ["fincrime", "product", "customer"];
         const type: isly.Type<"product" | "fincrime" | "customer">;
     }
-    const type: isly.object.ExtendableType<Base>;
+    const type: import("isly/dist/cjs/object").IslyObject<Base, object>;
 }

package/dist/Rule/Charge.d.ts

@@ -1,6 +1,5 @@
 import { isoly } from "isoly";
 import { selectively } from "selectively";
-import { isly } from "isly";
 import { Amount } from "../Amount";
 import { Exchange } from "../Exchange";
 import { Realm } from "../Realm";
@@ -26,7 +25,7 @@ export declare namespace Charge {
         };
     }
     namespace Api {
-        const type: isly.object.ExtendableType<Api>;
+        const type: import("isly/dist/cjs/object").IslyObject<Api, Base>;
     }
     function fromApi(rule: Api, realm: Realm): Charge;
     function fromApi(rule: Api, currency: isoly.Currency): Charge;

package/dist/Rule/Other.d.ts

@@ -12,7 +12,7 @@ export declare namespace Other {
         const values: readonly ["review", "reject", "flag"];
         const type: isly.Type<"reject" | "review" | "flag">;
     }
-    const type: isly.object.ExtendableType<Other>;
+    const type: import("isly/dist/cjs/object").IslyObject<Other, Base>;
     function evaluate(rules: Other[], state: State, macros?: Record<string, selectively.Definition>): {
         outcomes: Record<Other.Action, Other[]>;
         notes: Note[];

package/dist/Rule/Reserve.d.ts

@@ -1,6 +1,5 @@
 import { isoly } from "isoly";
 import { selectively } from "selectively";
-import { isly } from "isly";
 import { Amount } from "../Amount";
 import { Exchange } from "../Exchange";
 import { Realm } from "../Realm";
@@ -18,7 +17,7 @@ export declare namespace Reserve {
     namespace Action {
         const value = "reserve";
     }
-    const type: isly.object.ExtendableType<Reserve>;
+    const type: import("isly/dist/cjs/object").IslyObject<Reserve, Base>;
     interface Api extends Base {
         action: Reserve.Action;
         reserve: {
@@ -27,7 +26,7 @@ export declare namespace Reserve {
         };
     }
     namespace Api {
-        const type: isly.object.ExtendableType<Api>;
+        const type: import("isly/dist/cjs/object").IslyObject<Api, Base>;
     }
     function fromApi(rule: Api, realm: Realm): Reserve;
     function fromApi(rule: Api, currency: isoly.Currency): Reserve;

package/dist/Rule/Score.d.ts

@@ -15,7 +15,7 @@ export declare namespace Score {
     }
     type Risk = number;
     const Risk: isly.Type<number>;
-    const type: isly.object.ExtendableType<Score>;
+    const type: import("isly/dist/cjs/object").IslyObject<Score, Base>;
     function evaluate(rules: Score[], state: State, macros?: Record<string, selectively.Definition>): {
         outcomes: Score[];
         notes: Note[];

package/dist/Rule/State/Authorization.d.ts

@@ -18,7 +18,7 @@ export declare namespace Authorization {
     function toTransaction(authorization: Authorization): Transaction.Creatable & {
         counterpart: Rail.Address.Card.Counterpart;
     };
-    const type: isly.object.ExtendableType<Authorization>;
-    const is: isly.Type.IsFunction<Authorization>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Authorization, Omit<AuthorizationCreatable, "amount">>;
+    const is: (value: Authorization | any) => value is Authorization;
+    const flaw: (value: Authorization | any) => isly.Flaw;
 }

package/dist/Rule/State/Card.d.ts

@@ -30,7 +30,7 @@ export declare namespace Card {
     function from(card: ModelCard, statistics?: Statistics): Card;
     function check(card: Card, amount: number): TransactionStatus.Reason | undefined;
     function toAddress(card: Card): Rail.Address.Card;
-    const type: isly.object.ExtendableType<Card>;
-    const is: isly.Type.IsFunction<Card>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Card, Omit<ModelCard, "limit">>;
+    const is: (value: Card | any) => value is Card;
+    const flaw: (value: Card | any) => isly.Flaw;
 }

package/dist/Rule/State/Partial.d.ts

@@ -6,7 +6,7 @@ export interface Partial {
     card: Card;
 }
 export declare namespace Partial {
-    const type: isly.object.ExtendableType<Partial>;
-    const is: isly.Type.IsFunction<Partial>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Partial, object>;
+    const is: (value: Partial | any) => value is Partial;
+    const flaw: (value: Partial | any) => isly.Flaw;
 }

package/dist/Settlement/Amount.d.ts

@@ -1,5 +1,4 @@
 import { isoly } from "isoly";
-import { isly } from "isly";
 export type Amount = {
     net: number;
     fee: {
@@ -7,6 +6,6 @@ export type Amount = {
     };
 };
 export declare namespace Amount {
-    const type: isly.object.ExtendableType<Amount>;
+    const type: import("isly/dist/cjs/object").IslyObject<Amount, object>;
     function add(currency: isoly.Currency, addendee: Amount, addend: Partial<Amount>): Amount;
 }

package/dist/Settlement/Batch.d.ts

@@ -2,5 +2,5 @@ import { isly } from "isly";
 export type Batch = string;
 export declare namespace Batch {
     const type: isly.Type<string>;
-    const is: isly.Type.IsFunction<string>;
+    const is: (value: any | string) => value is string;
 }

package/dist/Settlement/Creatable.d.ts

@@ -9,7 +9,7 @@ export interface Creatable {
     batch: Batch;
 }
 export declare namespace Creatable {
-    const type: isly.object.ExtendableType<Creatable>;
-    const is: isly.Type.IsFunction<Creatable>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Creatable, object>;
+    const is: (value: Creatable | any) => value is Creatable;
+    const flaw: (value: Creatable | any) => isly.Flaw;
 }

package/dist/Settlement/Entry/Cancel.d.ts

@@ -17,11 +17,11 @@ export declare namespace Cancel {
         amount?: Amount;
     }
     namespace Creatable {
-        const type: isly.object.ExtendableType<Creatable>;
-        const is: isly.Type.IsFunction<Creatable>;
-        const flaw: isly.Type.FlawFunction;
+        const type: import("isly/dist/cjs/object").IslyObject<Creatable, object>;
+        const is: (value: Creatable | any) => value is Creatable;
+        const flaw: (value: Creatable | any) => isly.Flaw;
     }
-    const type: isly.object.ExtendableType<Cancel>;
-    const is: isly.Type.IsFunction<Cancel>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Cancel, Creatable>;
+    const is: (value: Cancel | any) => value is Cancel;
+    const flaw: (value: Cancel | any) => isly.Flaw;
 }

package/dist/Settlement/Entry/Capture.d.ts

@@ -18,11 +18,11 @@ export declare namespace Capture {
         amount: Amount;
     }
     namespace Creatable {
-        const type: isly.object.ExtendableType<Creatable>;
-        const is: isly.Type.IsFunction<Creatable>;
-        const flaw: isly.Type.FlawFunction;
+        const type: import("isly/dist/cjs/object").IslyObject<Creatable, object>;
+        const is: (value: Creatable | any) => value is Creatable;
+        const flaw: (value: Creatable | any) => isly.Flaw;
     }
-    const type: isly.object.ExtendableType<Capture>;
-    const is: isly.Type.IsFunction<Capture>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Capture, Creatable>;
+    const is: (value: Capture | any) => value is Capture;
+    const flaw: (value: Capture | any) => isly.Flaw;
 }

package/dist/Settlement/Entry/Creatable.d.ts

@@ -6,6 +6,6 @@ import { Unknown as EntryUnknown } from "./Unknown";
 export type Creatable = EntryCancel.Creatable | EntryCapture.Creatable | EntryRefund.Creatable | EntryUnknown.Creatable;
 export declare namespace Creatable {
     const type: isly.Type<EntryCancel.Creatable | EntryCapture.Creatable | EntryRefund.Creatable | EntryUnknown.Creatable>;
-    const is: isly.Type.IsFunction<EntryCancel.Creatable | EntryCapture.Creatable | EntryRefund.Creatable | EntryUnknown.Creatable>;
-    const flaw: isly.Type.FlawFunction;
+    const is: (value: any | (EntryCancel.Creatable | EntryCapture.Creatable | EntryRefund.Creatable | EntryUnknown.Creatable)) => value is EntryCancel.Creatable | EntryCapture.Creatable | EntryRefund.Creatable | EntryUnknown.Creatable;
+    const flaw: (value: (EntryCancel.Creatable | EntryCapture.Creatable | EntryRefund.Creatable | EntryUnknown.Creatable) | any) => isly.Flaw;
 }

package/dist/Settlement/Entry/Refund.d.ts

@@ -25,11 +25,11 @@ export declare namespace Refund {
     }
     function from(refund: Refund.Creatable, transaction: Transaction): Refund;
     namespace Creatable {
-        const type: isly.object.ExtendableType<Creatable>;
-        const is: isly.Type.IsFunction<Creatable>;
-        const flaw: isly.Type.FlawFunction;
+        const type: import("isly/dist/cjs/object").IslyObject<Creatable, object>;
+        const is: (value: Creatable | any) => value is Creatable;
+        const flaw: (value: Creatable | any) => isly.Flaw;
     }
-    const type: isly.object.ExtendableType<Refund>;
-    const is: isly.Type.IsFunction<Refund>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Refund, Creatable>;
+    const is: (value: Refund | any) => value is Refund;
+    const flaw: (value: Refund | any) => isly.Flaw;
 }

package/dist/Settlement/Entry/Summary.d.ts

@@ -6,7 +6,7 @@ export interface Summary {
     };
 }
 export declare namespace Summary {
-    const type: isly.object.ExtendableType<Summary>;
-    const is: isly.Type.IsFunction<Summary>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Summary, object>;
+    const is: (value: Summary | any) => value is Summary;
+    const flaw: (value: Summary | any) => isly.Flaw;
 }

package/dist/Settlement/Entry/Unknown.d.ts

@@ -13,12 +13,12 @@ export declare namespace Unknown {
         batch: Batch;
     }
     namespace Creatable {
-        const type: isly.object.ExtendableType<Creatable>;
-        const is: isly.Type.IsFunction<Unknown>;
-        const flaw: isly.Type.FlawFunction;
+        const type: import("isly/dist/cjs/object").IslyObject<Creatable, object>;
+        const is: (value: Unknown | any) => value is Unknown;
+        const flaw: (value: Unknown | any) => isly.Flaw;
     }
     function from(creatable: Creatable): Unknown;
-    const type: isly.object.ExtendableType<Unknown>;
-    const is: isly.Type.IsFunction<Unknown>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Unknown, Creatable>;
+    const is: (value: Unknown | any) => value is Unknown;
+    const flaw: (value: Unknown | any) => isly.Flaw;
 }

package/dist/Settlement/Entry/index.d.ts

@@ -36,6 +36,6 @@ export declare namespace Entry {
     const Creatable: typeof EntryCreatable;
     function from(creatable: Entry.Creatable, transaction: Transaction | gracely.Error | string): Entry;
     const type: isly.Type<Entry>;
-    const is: isly.Type.IsFunction<Entry>;
-    const flaw: isly.Type.FlawFunction;
+    const is: (value: any | Entry) => value is Entry;
+    const flaw: (value: Entry | any) => isly.Flaw;
 }

package/dist/Settlement/Fee.d.ts

@@ -5,7 +5,7 @@ export interface Fee {
 }
 export declare namespace Fee {
     function add(addendee: Fee, addend: Fee): Fee;
-    const type: isly.object.ExtendableType<Fee>;
-    const is: isly.Type.IsFunction<Fee>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Fee, object>;
+    const is: (value: Fee | any) => value is Fee;
+    const flaw: (value: Fee | any) => isly.Flaw;
 }

package/dist/Settlement/Status.d.ts

@@ -6,7 +6,7 @@ export interface Status {
 export declare namespace Status {
     const values: readonly ["pending", "failed", "partial", "done"];
     type Values = typeof values[number];
-    const type: isly.object.ExtendableType<Status>;
-    const is: isly.Type.IsFunction<Status>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Status, object>;
+    const is: (value: Status | any) => value is Status;
+    const flaw: (value: Status | any) => isly.Flaw;
 }

package/dist/Settlement/Total.d.ts

@@ -1,5 +1,4 @@
 import { isoly } from "isoly";
-import { isly } from "isly";
 import { Amount } from "./Amount";
 export interface Total {
     expected: Amount;
@@ -18,8 +17,8 @@ export declare namespace Total {
         net: number;
         transactions: string[];
     };
-    const Settled: isly.object.ExtendableType<Settled>;
-    const type: isly.object.ExtendableType<Total>;
+    const Settled: import("isly/dist/cjs/object").IslyObject<Settled, object>;
+    const type: import("isly/dist/cjs/object").IslyObject<Total, object>;
     function create(): Total;
     function verify(total: Total, type: "outcome" | "settled"): boolean;
     function add(currency: isoly.Currency, addendee: Total, addend: Partial<Total>): Total;

package/dist/Settlement/index.d.ts

@@ -46,8 +46,8 @@ export declare namespace Settlement {
     };
     export type MaybeOld = Settlement | OldSettlement;
     export function fromLegacy(settlement: MaybeOld): Settlement;
-    export const type: isly.object.ExtendableType<Settlement>;
-    export const is: isly.Type.IsFunction<Settlement>;
-    export const flaw: isly.Type.FlawFunction;
+    export const type: import("isly/dist/cjs/object").IslyObject<Settlement, Creatable>;
+    export const is: (value: Settlement | any) => value is Settlement;
+    export const flaw: (value: Settlement | any) => isly.Flaw;
     export {};
 }

package/dist/Supplier/index.d.ts

@@ -3,5 +3,5 @@ export type Supplier = typeof Supplier.names[number];
 export declare namespace Supplier {
     const names: readonly ["paxgiro", "clearbank", "paxgiroCredit"];
     const type: isly.Type<"paxgiro" | "clearbank" | "paxgiroCredit">;
-    const is: isly.Type.IsFunction<"paxgiro" | "clearbank" | "paxgiroCredit">;
+    const is: (value: any | ("paxgiro" | "clearbank" | "paxgiroCredit")) => value is "paxgiro" | "clearbank" | "paxgiroCredit";
 }

package/dist/Transaction/Creatable.d.ts

@@ -11,8 +11,8 @@ export declare namespace Creatable {
     type Resolved = Creatable & {
         counterpart: Rail.Address;
     };
-    const type: isly.object.ExtendableType<Creatable>;
-    const is: isly.Type.IsFunction<Creatable>;
-    const flaw: isly.Type.FlawFunction;
-    const get: isly.Type.GetFunction<Creatable>;
+    const type: import("isly/dist/cjs/object").IslyObject<Creatable, object>;
+    const is: (value: Creatable | any) => value is Creatable;
+    const flaw: (value: Creatable | any) => isly.Flaw;
+    const get: (value: any) => Creatable | undefined;
 }

package/dist/Transaction/Incoming.d.ts

@@ -14,8 +14,8 @@ export interface Incoming {
     reference?: TransactionReference;
 }
 export declare namespace Incoming {
-    const type: isly.object.ExtendableType<Incoming>;
-    const is: isly.Type.IsFunction<Incoming>;
-    const flaw: isly.Type.FlawFunction;
+    const type: import("isly/dist/cjs/object").IslyObject<Incoming, object>;
+    const is: (value: Incoming | any) => value is Incoming;
+    const flaw: (value: Incoming | any) => isly.Flaw;
     function fromRefund(entry: Settlement.Entry.Refund.Creatable, card: Rail.Address.Card): Incoming;
 }

package/dist/Transaction/Note.d.ts

@@ -1,5 +1,4 @@
 import { isoly } from "isoly";
-import { isly } from "isly";
 import type { Rule } from "../Rule";
 export interface Note extends Note.Creatable {
     author: string;
@@ -14,9 +13,9 @@ export declare namespace Note {
         rule?: Rule;
     }
     namespace Creatable {
-        const type: isly.object.ExtendableType<Creatable>;
-        const is: isly.Type.IsFunction<Creatable>;
+        const type: import("isly/dist/cjs/object").IslyObject<Creatable, object>;
+        const is: (value: Creatable | any) => value is Creatable;
     }
-    const type: isly.object.ExtendableType<Note>;
-    const is: isly.Type.IsFunction<Note>;
+    const type: import("isly/dist/cjs/object").IslyObject<Note, Creatable>;
+    const is: (value: Note | any) => value is Note;
 }

package/dist/Transaction/Reference.d.ts

@@ -1,4 +1,3 @@
-import { isly } from "isly";
 import { Supplier } from "../Supplier";
 export interface Reference {
     supplier?: Supplier;
@@ -7,6 +6,6 @@ export interface Reference {
     endToEndId?: string;
 }
 export declare namespace Reference {
-    const type: isly.object.ExtendableType<Reference>;
-    const is: isly.Type.IsFunction<Reference>;
+    const type: import("isly/dist/cjs/object").IslyObject<Reference, object>;
+    const is: (value: Reference | any) => value is Reference;
 }

package/dist/Transaction/Statistics.d.ts

@@ -26,7 +26,7 @@ export declare namespace Statistics {
             extraRegion: any;
         }>;
     }
-    const type: isly.object.ExtendableType<Transaction.Statistics>;
+    const type: import("isly/dist/cjs/object").IslyObject<Transaction.Statistics, object>;
     function append(statistics: Statistics, transaction: Transaction, domestic: isoly.CountryCode.Alpha2[], intraRegion: isoly.CountryCode.Alpha2[], currency: isoly.Currency): Statistics;
     function combine(accumulation: Statistics, incoming: Statistics, currency: isoly.Currency): Statistics;
 }

package/dist/Transaction/index.d.ts

@@ -53,7 +53,7 @@ export declare namespace Transaction {
         total: number;
     };
     namespace Amount {
-        const type: isly.object.ExtendableType<Amount>;
+        const type: import("isly/dist/cjs/object").IslyObject<Amount, object>;
         function fromState(state: Rule.State): Amount;
         function fromOperations(transaction: Transaction | Transaction.Creatable, operations: Operation[], state?: Rule.State): Amount;
         function change(currency: isoly.Currency, amount: Amount, change: number, type: Exclude<keyof Amount, "total">): Amount;
@@ -68,23 +68,23 @@ export declare namespace Transaction {
     export import Note = TransactionNote;
     export import Status = TransactionStatus;
     export import Statistics = TransactionStatistics;
-    const type: isly.object.ExtendableType<Transaction>;
-    const is: isly.Type.IsFunction<Transaction>;
-    const flaw: isly.Type.FlawFunction;
-    const get: isly.Type.GetFunction<Transaction>;
+    const type: import("isly/dist/cjs/object").IslyObject<Transaction, object>;
+    const is: (value: Transaction | any) => value is Transaction;
+    const flaw: (value: Transaction | any) => isly.Flaw;
+    const get: (value: any) => Transaction | undefined;
     interface Legacy extends Omit<Transaction, "amount"> {
         amount: number;
     }
     namespace Legacy {
-        const type: isly.object.ExtendableType<Legacy>;
+        const type: import("isly/dist/cjs/object").IslyObject<Legacy, Omit<Transaction, "amount">>;
     }
     function fromLegacy(transaction: Transaction | Legacy): Transaction;
     function toLegacy(transaction: Transaction | Legacy): Legacy;
     type Event = Omit<Transaction, "state">;
     namespace Event {
-        const type: isly.object.ExtendableType<Omit<Transaction, "state">>;
-        const is: isly.Type.IsFunction<Omit<Transaction, "state">>;
-        const get: isly.Type.GetFunction<Omit<Transaction, "state">>;
+        const type: import("isly/dist/cjs/object").IslyObject<Omit<Transaction, "state">, object>;
+        const is: (value: Omit<Transaction, "state"> | any) => value is Omit<Transaction, "state">;
+        const get: (value: any) => Omit<Transaction, "state"> | undefined;
         function from(transaction: Transaction): Event;
     }
     function fromCreatable(creatable: Creatable.Resolved, id: string, state: Rule.State.Evaluated, account: {

package/dist/Treasury/Account/Conditions.d.ts

@@ -1,9 +1,8 @@
-import { isly } from "isly";
 import { Amounts } from "../../Amounts";
 export interface Conditions {
     minimum?: Amounts;
 }
 export declare namespace Conditions {
-    const type: isly.object.ExtendableType<Conditions>;
-    const is: isly.Type.IsFunction<Conditions>;
+    const type: import("isly/dist/cjs/object").IslyObject<Conditions, object>;
+    const is: (value: Conditions | any) => value is Conditions;
 }

package/dist/Treasury/Account/Fetchable.d.ts

@@ -1,5 +1,4 @@
 import { isoly } from "isoly";
-import { isly } from "isly";
 import { Rail } from "../../Rail";
 import { Supplier } from "../../Supplier";
 import { Balance } from "../Balance";
@@ -14,5 +13,5 @@ export interface Fetchable {
     balance: Balance;
 }
 export declare namespace Fetchable {
-    const type: isly.object.ExtendableType<Fetchable>;
+    const type: import("isly/dist/cjs/object").IslyObject<Fetchable, object>;
 }

package/dist/Treasury/Account/Storable.d.ts

@@ -1,5 +1,4 @@
 import { isoly } from "isoly";
-import { isly } from "isly";
 import { Realm } from "../../Realm";
 import { Supplier } from "../../Supplier";
 import { Category } from "./Category";
@@ -14,5 +13,5 @@ export interface Storable {
     conditions?: Conditions;
 }
 export declare namespace Storable {
-    const type: isly.object.ExtendableType<Storable>;
+    const type: import("isly/dist/cjs/object").IslyObject<Storable, object>;
 }

package/dist/Treasury/Account/index.d.ts

@@ -1,5 +1,4 @@
 import { isoly } from "isoly";
-import { isly } from "isly";
 import { Rail } from "../../Rail";
 import { Realm } from "../../Realm";
 import { Supplier } from "../../Supplier";
@@ -25,7 +24,7 @@ export interface Account {
     balance: Balance;
 }
 export declare namespace Account {
-    const type: isly.object.ExtendableType<Account>;
+    const type: import("isly/dist/cjs/object").IslyObject<Account, object>;
     type Listable = Account & {
         transactions: Transaction[];
     };