@pax2pay/model-banking 0.1.582 → 0.1.584

package/Identifier.ts

@@ -1,7 +1,7 @@
 import { cryptly } from "cryptly"
 import { isoly } from "isoly"
 import { isly } from "isly"
-import * as z from "zod"
+import { zod } from "./zod"
 
 export type Identifier = cryptly.Identifier
 export namespace Identifier {
@@ -20,5 +20,5 @@ export namespace Identifier {
 		return isoly.DateTime.create(Number(new BigUint64Array(decoded.slice(decoded.length - 8).buffer)), "milliseconds")
 	}
 	export const type = isly.fromIs("Identifier", cryptly.Identifier.is)
-	export const zodType = z.string().refine(cryptly.Identifier.is)
+	export const typeZod = zod.string().refine(cryptly.Identifier.is)
 }

package/Log/Entry.ts

@@ -1,12 +1,12 @@
-import * as z from "zod"
+import { zod } from "../zod"
 
 export namespace Entry {
-	export const type = z.object({
-		message: z.string(),
-		data: z.any().optional(),
+	export const type = zod.object({
+		message: zod.string(),
+		data: zod.any().optional(),
 	})
 	export namespace Message {
-		export const type = z.object({ ...Entry.type.shape, resource: z.string().optional() })
+		export const type = zod.object({ ...Entry.type.shape, resource: zod.string().optional() })
 		export function to(message: string, data: any | undefined, resource: string | undefined): Entry.Message {
 			const result: Entry.Message = { message }
 			resource && (result.resource = resource)
@@ -14,6 +14,6 @@ export namespace Entry {
 			return result
 		}
 	}
-	export type Message = z.infer<typeof Message.type>
+	export type Message = zod.infer<typeof Message.type>
 }
-export type Entry = z.infer<typeof Entry.type>
+export type Entry = zod.infer<typeof Entry.type>

package/Log/Locations.ts

@@ -1,11 +1,11 @@
-import * as z from "zod"
+import { zod } from "../zod"
 
 export namespace Locations {
-	export const type = z.object({
-		cfConnectionIp: z.string().optional(),
-		cfIpCountry: z.string().optional(),
-		datacenter: z.string().optional(),
-		country: z.string().optional(),
+	export const type = zod.object({
+		cfConnectionIp: zod.string().optional(),
+		cfIpCountry: zod.string().optional(),
+		datacenter: zod.string().optional(),
+		country: zod.string().optional(),
 	})
 	export function getLocations(request: any): Locations | undefined {
 		const locations = {
@@ -17,4 +17,4 @@ export namespace Locations {
 		return type.safeParse(locations).success ? locations : undefined
 	}
 }
-export type Locations = z.infer<typeof Locations.type>
+export type Locations = zod.infer<typeof Locations.type>

package/Log/Message/Configuration.ts

@@ -1,13 +1,13 @@
 import { TraceLog } from "@cloudflare/workers-types"
-import * as z from "zod"
 import { Realm } from "../../Realm"
+import { zod } from "../../zod"
 
 export namespace Configuration {
-	export const type = z.object({
-		realm: Realm.zodType,
-		collection: z.string(),
-		resource: z.string().optional(),
-		requireEntries: z.boolean().optional(),
+	export const type = zod.object({
+		realm: Realm.typeZod,
+		collection: zod.string(),
+		resource: zod.string().optional(),
+		requireEntries: zod.boolean().optional(),
 	})
 	export function fromTraceLog(trace: TraceLog | undefined): Configuration | undefined {
 		return trace && Configuration.type.safeParse(trace.message[0]).success
@@ -20,4 +20,4 @@ export namespace Configuration {
 			: undefined
 	}
 }
-export type Configuration = z.infer<typeof Configuration.type>
+export type Configuration = zod.infer<typeof Configuration.type>

package/Log/Message/Entry.ts

@@ -1,12 +1,12 @@
 import { TraceLog } from "@cloudflare/workers-types"
-import * as z from "zod"
+import { zod } from "../../zod"
 import type { Log } from "../index"
 
 export namespace Entry {
-	export const type = z.object({
-		message: z.string(),
-		resource: z.string().optional(),
-		data: z.any().optional(),
+	export const type = zod.object({
+		message: zod.string(),
+		resource: zod.string().optional(),
+		data: zod.any().optional(),
 	})
 	export function fromEventLogs(trace: TraceLog): { entry: Log.Entry; resource: Log["resource"] } | undefined {
 		return Entry.type.safeParse(trace.message[0]).success
@@ -20,4 +20,4 @@ export namespace Entry {
 			: undefined
 	}
 }
-export type Entry = z.infer<typeof Entry.type>
+export type Entry = zod.infer<typeof Entry.type>

package/Log/index.ts

@@ -1,8 +1,8 @@
 import { isoly } from "isoly"
 import { TraceItem } from "@cloudflare/workers-types"
-import * as z from "zod"
 import { Identifier } from "../Identifier"
 import { Realm } from "../Realm"
+import { zod } from "../zod"
 import { Entry as LogEntry } from "./Entry"
 import { Locations as LogLocations } from "./Locations"
 import { Message as LogMessage } from "./Message"
@@ -11,14 +11,14 @@ export namespace Log {
 	export import Message = LogMessage
 	export import Entry = LogEntry
 	export import Locations = LogLocations
-	export const type = z.object({
-		id: Identifier.zodType,
-		realm: Realm.zodType,
-		script: z.string().optional(),
-		collection: z.string(),
-		resource: z.string().optional(),
+	export const type = zod.object({
+		id: Identifier.typeZod,
+		realm: Realm.typeZod,
+		script: zod.string().optional(),
+		collection: zod.string(),
+		resource: zod.string().optional(),
 		entries: Log.Entry.type.array(),
-		created: z.iso.datetime({ offset: true }),
+		created: zod.iso.datetime({ offset: true }),
 	})
 	export function fromEvents(events: TraceItem[]): Log[] {
 		const result: Log[] = []
@@ -65,4 +65,4 @@ export namespace Log {
 		console.error(Log.Entry.Message.to(message, data, resource))
 	}
 }
-export type Log = z.infer<typeof Log.type>
+export type Log = zod.infer<typeof Log.type>

package/Realm.ts

@@ -1,15 +1,15 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { isly as isly2 } from "isly2"
-import * as z from "zod"
 import { Supplier as modelSupplier } from "./Supplier"
+import { zod } from "./zod"
 
-export type Realm = typeof Realm.realms[number]
+export type Realm = zod.infer<typeof Realm.typeZod>
 
 export namespace Realm {
 	export const realms = ["test", "uk", "uguk", "eea"] as const
 	export const type = isly.string<Realm>(realms)
-	export const zodType = z.enum(realms)
+	export const typeZod = zod.enum(realms)
 	export const type2 = isly2
 		.string<Realm>("value", ...realms)
 		.rename("Realm")

package/User/Access/Permission.ts

@@ -1,7 +1,8 @@
 import { isly } from "isly"
 import { typedly } from "typedly"
+import { zod } from "../../zod"
 
-export type Permission = Partial<Record<Permission.Collection, Permission.Level>>
+export type Permission = zod.infer<typeof Permission.typeZod>
 export namespace Permission {
 	export type Realm = Record<Permission.Collection.Realm, Permission.Level>
 	export type Global = Record<Permission.Collection.Global, Permission.Level>
@@ -12,9 +13,10 @@ export namespace Permission {
 				(collection != "user" && Permission.Level.get(privilege["*"]) >= Permission.Level.get(level))
 		)
 	}
-	export type Level = typeof Level.values[number]
+	export type Level = zod.infer<typeof Level.typeZod>
 	export namespace Level {
 		export const values = ["read", "write", "developer", "admin"] as const
+		export const typeZod = zod.enum(values)
 		export const type = isly.string(values)
 		export function get(level: Level | undefined): number {
 			return level ? value[level] : 0
@@ -26,7 +28,7 @@ export namespace Permission {
 			admin: 4,
 		} as const
 	}
-	export type Collection = typeof Collection.values[number]
+	export type Collection = zod.infer<typeof Collection.typeZod>
 	export namespace Collection {
 		export type Realm = typeof Realm.values[number]
 		export namespace Realm {
@@ -47,7 +49,9 @@ export namespace Permission {
 			export const values = ["user"] as const
 		}
 		export const values = [...Realm.values, ...Global.values] as const
+		export const typeZod = zod.enum(values)
 		export const type = isly.string(values)
 	}
 	export const type = isly.record<Permission>(Collection.type, Level.type)
+	export const typeZod = zod.partialRecord(Collection.typeZod, Level.typeZod)
 }

package/User/Access/index.ts

@@ -1,14 +1,9 @@
 import { isly } from "isly"
+import { zod } from "../../zod"
 import { Permission as AccessPermission } from "./Permission"
 
 /** read < write < developer < admin */
-export interface Access {
-	uk?: Access.Permission.Realm
-	uguk?: Access.Permission.Realm
-	eea?: Access.Permission.Realm
-	test?: Access.Permission.Realm
-	"*"?: Access.Permission.Global
-}
+export type Access = zod.infer<typeof Access.typeZod>
 export namespace Access {
 	export import Permission = AccessPermission
 	export const type = isly.object({
@@ -18,4 +13,11 @@ export namespace Access {
 		test: Access.Permission.type.optional(),
 		"*": isly.object({ user: Access.Permission.Level.type.optional() }).optional(),
 	})
+	export const typeZod = zod.object({
+		uk: Access.Permission.typeZod.optional(),
+		uguk: Access.Permission.typeZod.optional(),
+		eea: Access.Permission.typeZod.optional(),
+		test: Access.Permission.typeZod.optional(),
+		"*": zod.object({ user: Access.Permission.Level.typeZod.optional() }).optional(),
+	})
 }

package/User/JWT/Payload.ts

@@ -1,56 +1,55 @@
-import { authly } from "authly"
 import { isly } from "isly"
 import { Realm } from "../../Realm"
+import { zod } from "../../zod"
 import { Access } from "../Access"
 
-export type Payload = Payload.LongTerm | Payload.ShortTerm
+export type Payload = Payload.LongTerm | Payload.ShortTerm //zod.infer<typeof Payload.typeZod>
 export namespace Payload {
-	export interface Creatable {
-		sub: string
-		permission: Access.Permission
-		realm: Realm
-	}
+	export type Creatable = zod.infer<typeof Creatable.typeZod>
 	export namespace Creatable {
 		export const type = isly.object<Creatable>({
 			sub: isly.string(),
 			permission: Access.Permission.type,
 			realm: Realm.type,
 		})
+		export const typeZod = zod.object({
+			sub: zod.string(),
+			permission: Access.Permission.typeZod,
+			realm: Realm.typeZod,
+		})
 	}
-	export interface Base extends authly.Payload {
-		aud: string
-		iat: number
-		iss: string
-		sub: string
-		permission: Access.Permission
-		realm: Realm
-	}
+	export type Base = zod.infer<typeof Base.typeZod>
 	export namespace Base {
-		export const type = isly.object<Payload>({
+		export const type = isly.object<Base>({
 			aud: isly.string(),
 			iat: isly.number(),
 			iss: isly.string(),
 			sub: isly.string(),
 			permission: Access.Permission.type,
 			realm: Realm.type,
+			token: isly.string().optional(),
+		})
+		export const typeZod = zod.object({
+			aud: zod.string(),
+			iat: zod.number(),
+			iss: zod.string(),
+			sub: zod.string(),
+			permission: Access.Permission.typeZod,
+			realm: Realm.typeZod,
+			token: zod.string().optional(),
 		})
 	}
-	export interface LongTerm extends Base {
-		id: string
-	}
+	export type LongTerm = zod.infer<typeof LongTerm.typeZod>
 	export namespace LongTerm {
 		export const type = Base.type.extend<LongTerm>({ id: isly.string() })
+		export const typeZod = Base.typeZod.extend({ id: zod.string() })
 	}
-	export interface ShortTerm extends Base {
-		exp: number
-	}
+	export type ShortTerm = zod.infer<typeof ShortTerm.typeZod>
 	export namespace ShortTerm {
 		export const type = Base.type.extend<ShortTerm>({ exp: isly.number() })
+		export const typeZod = Base.typeZod.extend({ exp: zod.number() })
 	}
-
-	export const configuration = {
-		aud: "https://banking.pax2pay.app",
-		iss: "pax2pay",
-	}
+	export const configuration = { aud: "https://banking.pax2pay.app", iss: "pax2pay" }
 	export const type = isly.union<Payload>(LongTerm.type, ShortTerm.type)
+	export const typeZod = zod.union([LongTerm.typeZod, ShortTerm.typeZod])
 }

package/User/JWT/index.ts

@@ -28,8 +28,8 @@ export class JWT {
 		const verified = await this.verifier?.verify(token, JWT.Payload.configuration.aud)
 		delete verified?.token
 		return JWT.Payload.type.is(verified) &&
-			verified?.iss == JWT.Payload.configuration.iss &&
-			(verified.exp || (verified.id && (await this.store?.get(verified.id as string).then(s => s?.value))))
+			verified.iss == JWT.Payload.configuration.iss &&
+			("exp" in verified || (await this.store?.get(verified.id).then(s => s?.value)))
 			? verified
 			: undefined
 	}

package/User/Password.ts

@@ -2,18 +2,16 @@ import { cryptly } from "cryptly"
 import { gracely } from "gracely"
 import { isoly } from "isoly"
 import { isly } from "isly"
+import { zod } from "../zod"
 
 export interface Password {
 	hash: cryptly.Password.Hash
 	changed: isoly.DateTime
 }
 export namespace Password {
-	export interface Creatable {
-		current?: string
-		new: string
-		repeat: string
-	}
+	export type Creatable = zod.infer<typeof Creatable.typeZod>
 	export namespace Creatable {
+		export const typeZod = zod.object({ current: zod.string().optional(), new: zod.string(), repeat: zod.string() })
 		export const type = isly.object<Creatable>({
 			current: isly.string().optional(),
 			new: isly.string(),

package/User/index.ts

@@ -1,6 +1,7 @@
 import { isoly } from "isoly"
 import { isly } from "isly"
 import { Realm } from "../Realm"
+import { zod } from "../zod"
 import { Access as UserAccess } from "./Access"
 import { Identity as UserIdentity } from "./Identity"
 import { JWT as UserJWT } from "./JWT"
@@ -11,9 +12,7 @@ export interface User {
 	access: User.Access
 	changed: isoly.DateTime
 	created: isoly.DateTime
-	password: {
-		changed: isoly.DateTime
-	}
+	password: { changed: isoly.DateTime }
 }
 export namespace User {
 	export import Access = UserAccess
@@ -22,32 +21,15 @@ export namespace User {
 	export import Password = UserPassword
 	export function fromInvite(invite: Invite): User {
 		const now = isoly.DateTime.now()
-		return {
-			email: invite.email,
-			access: invite.access,
-			changed: now,
-			created: now,
-			password: {
-				changed: now,
-			},
-		}
+		return { email: invite.email, access: invite.access, changed: now, created: now, password: { changed: now } }
 	}
 	export function toJWTPayloadCreatable(user: User, realm: Realm): User.JWT.Payload.Creatable {
-		return {
-			sub: user.email,
-			permission: { ...(user.access[realm] ?? {}), ...(user.access["*"] ?? {}) },
-			realm,
-		}
-	}
-	export interface Creatable {
-		invite: string
-		password: Password.Creatable
+		return { sub: user.email, permission: { ...(user.access[realm] ?? {}), ...(user.access["*"] ?? {}) }, realm }
 	}
+	export type Creatable = zod.infer<typeof Creatable.typeZod>
 	export namespace Creatable {
-		export const type = isly.object<Creatable>({
-			invite: isly.string(),
-			password: Password.Creatable.type,
-		})
+		export const type = isly.object<Creatable>({ invite: isly.string(), password: Password.Creatable.type })
+		export const typeZod = zod.object({ invite: zod.string(), password: Password.Creatable.typeZod })
 	}
 	export interface Invite {
 		id: string
@@ -55,11 +37,9 @@ export namespace User {
 		access: Access
 	}
 	export namespace Invite {
-		export interface Creatable {
-			email: string
-			access: Access
-		}
+		export type Creatable = zod.infer<typeof Creatable.typeZod>
 		export namespace Creatable {
+			export const typeZod = zod.object({ email: zod.string(), access: Access.typeZod })
 			export const type = isly.object<Creatable>({ email: isly.string(), access: Access.type })
 		}
 	}

package/Warning/Base.ts

@@ -4,6 +4,7 @@ import { Issue } from "./Issue"
 
 export interface Base {
 	type: string
+	severity?: Base.Severity
 	resource: string
 	value?: number
 	date: isoly.Date
@@ -11,8 +12,14 @@ export interface Base {
 }
 
 export namespace Base {
+	export type Severity = typeof Severity.values[number]
+	export namespace Severity {
+		export const values = ["low", "medium", "high"] as const
+		export const type = isly.string<Severity>(values)
+	}
 	export const type = isly.object<Base>({
 		type: isly.string(),
+		severity: Severity.type.optional(),
 		resource: isly.string(),
 		value: isly.number().optional(),
 		date: isly.string(),

package/Warning/Snapshot/Counterbalance.ts

@@ -4,11 +4,13 @@ import { Base } from "../Base"
 
 export interface Counterbalance extends Base {
 	type: "counterbalance"
+	severity?: "low"
 	currency: isoly.Currency
 }
 export namespace Counterbalance {
 	export const type = Base.type.extend<Counterbalance>({
 		type: isly.string("counterbalance"),
+		severity: isly.string("low").optional(),
 		currency: isly.string(),
 	})
 }

package/Warning/Snapshot/MissingBuffer.ts

@@ -5,6 +5,7 @@ import { Base } from "../Base"
 
 export interface MissingBuffer extends Base {
 	type: "missing-buffer"
+	severity?: "high"
 	currency: isoly.Currency
 	minimum: number
 	balance: number
@@ -12,6 +13,7 @@ export interface MissingBuffer extends Base {
 export namespace MissingBuffer {
 	export const type = Base.type.extend<MissingBuffer>({
 		type: isly.string("missing-buffer"),
+		severity: isly.string("high").optional(),
 		currency: isly.string(),
 		minimum: isly.number(),
 		balance: isly.number(),

package/Warning/Snapshot/MissingEmoney.ts

@@ -4,11 +4,13 @@ import { Base } from "../Base"
 
 export interface MissingEmoney extends Base {
 	type: "missing-emoney"
+	severity?: "high"
 	currency: isoly.Currency
 }
 export namespace MissingEmoney {
 	export const type = Base.type.extend<MissingEmoney>({
 		type: isly.string("missing-emoney"),
+		severity: isly.string("high").optional(),
 		currency: isly.string(),
 	})
 }

package/Warning/Snapshot/MissingFiat.ts

@@ -4,11 +4,13 @@ import { Base } from "../Base"
 
 export interface MissingFiat extends Base {
 	type: "missing-fiat"
+	severity?: "high"
 	currency: isoly.Currency
 }
 export namespace MissingFiat {
 	export const type = Base.type.extend<MissingFiat>({
 		type: isly.string("missing-fiat"),
+		severity: isly.string("high").optional(),
 		currency: isly.string(),
 	})
 }

package/Warning/Snapshot/Overdraft.ts

@@ -4,6 +4,7 @@ import { Base } from "../Base"
 
 export interface Overdraft extends Base {
 	type: "overdraft"
+	severity?: "medium"
 	organization: string
 	currency: isoly.Currency
 }
@@ -11,6 +12,7 @@ export interface Overdraft extends Base {
 export namespace Overdraft {
 	export const type = Base.type.extend<Overdraft>({
 		type: isly.string("overdraft"),
+		severity: isly.string("medium").optional(),
 		organization: isly.string(),
 		currency: isly.fromIs("Currency", isoly.Currency.is),
 	})

package/Warning/Snapshot/StaleFiat.ts

@@ -6,12 +6,14 @@ import { Base } from "../Base"
 
 export interface StaleFiat extends Base {
 	type: "stale-fiat"
+	severity?: "low"
 	currency: isoly.Currency
 	transaction: { id: string; created: isoly.DateTime }
 }
 export namespace StaleFiat {
 	export const type = Base.type.extend<StaleFiat>({
 		type: isly.string("stale-fiat"),
+		severity: isly.string("low").optional(),
 		currency: isly.string(),
 		transaction: isly.object<StaleFiat["transaction"]>({ id: isly.string(), created: isly.string() }),
 	})

package/dist/cjs/Identifier.d.ts

@@ -1,11 +1,11 @@
 import { cryptly } from "cryptly";
 import { isoly } from "isoly";
 import { isly } from "isly";
-import * as z from "zod";
+import { zod } from "./zod";
 export type Identifier = cryptly.Identifier;
 export declare namespace Identifier {
     function generate(date?: isoly.DateTime, length?: cryptly.Identifier.Length, ordering?: "ordered" | "reversed"): string;
     function timeOf(identifier: cryptly.Identifier, ordering?: "ordered" | "reversed"): isoly.DateTime;
     const type: isly.Type<string>;
-    const zodType: z.ZodString;
+    const typeZod: zod.ZodString;
 }

package/dist/cjs/Identifier.js

@@ -1,43 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Identifier = void 0;
 const cryptly_1 = require("cryptly");
 const isoly_1 = require("isoly");
 const isly_1 = require("isly");
-const z = __importStar(require("zod"));
+const zod_1 = require("./zod");
 var Identifier;
 (function (Identifier) {
     function generate(date = isoly_1.isoly.DateTime.now(), length = 16, ordering = "reversed") {
@@ -50,6 +17,6 @@ var Identifier;
     }
     Identifier.timeOf = timeOf;
     Identifier.type = isly_1.isly.fromIs("Identifier", cryptly_1.cryptly.Identifier.is);
-    Identifier.zodType = z.string().refine(cryptly_1.cryptly.Identifier.is);
+    Identifier.typeZod = zod_1.zod.string().refine(cryptly_1.cryptly.Identifier.is);
 })(Identifier || (exports.Identifier = Identifier = {}));
 //# sourceMappingURL=Identifier.js.map

package/dist/cjs/Identifier.js.map

@@ -1 +1 @@
-{"version":3,"file":"Identifier.js","sourceRoot":"","sources":["../../Identifier.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qCAAiC;AACjC,iCAA6B;AAC7B,+BAA2B;AAC3B,uCAAwB;AAGxB,IAAiB,UAAU,CAiB1B;AAjBD,WAAiB,UAAU;IAC1B,SAAgB,QAAQ,CACvB,OAAuB,aAAK,CAAC,QAAQ,CAAC,GAAG,EAAE,EAC3C,SAAoC,EAAE,EACtC,WAAmC,UAAU;QAE7C,OAAO,iBAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,EAAE,aAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAA;IACjG,CAAC;IANe,mBAAQ,WAMvB,CAAA;IACD,SAAgB,MAAM,CACrB,UAA8B,EAC9B,WAAmC,UAAU;QAE7C,MAAM,OAAO,GAAG,iBAAO,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;QAC3D,OAAO,aAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,cAAc,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;IACnH,CAAC;IANe,iBAAM,SAMrB,CAAA;IACY,eAAI,GAAG,WAAI,CAAC,MAAM,CAAC,YAAY,EAAE,iBAAO,CAAC,UAAU,CAAC,EAAE,CAAC,CAAA;IACvD,kBAAO,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,iBAAO,CAAC,UAAU,CAAC,EAAE,CAAC,CAAA;AAChE,CAAC,EAjBgB,UAAU,0BAAV,UAAU,QAiB1B"}
+{"version":3,"file":"Identifier.js","sourceRoot":"","sources":["../../Identifier.ts"],"names":[],"mappings":";;;AAAA,qCAAiC;AACjC,iCAA6B;AAC7B,+BAA2B;AAC3B,+BAA2B;AAG3B,IAAiB,UAAU,CAiB1B;AAjBD,WAAiB,UAAU;IAC1B,SAAgB,QAAQ,CACvB,OAAuB,aAAK,CAAC,QAAQ,CAAC,GAAG,EAAE,EAC3C,SAAoC,EAAE,EACtC,WAAmC,UAAU;QAE7C,OAAO,iBAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,EAAE,aAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAA;IACjG,CAAC;IANe,mBAAQ,WAMvB,CAAA;IACD,SAAgB,MAAM,CACrB,UAA8B,EAC9B,WAAmC,UAAU;QAE7C,MAAM,OAAO,GAAG,iBAAO,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;QAC3D,OAAO,aAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,cAAc,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;IACnH,CAAC;IANe,iBAAM,SAMrB,CAAA;IACY,eAAI,GAAG,WAAI,CAAC,MAAM,CAAC,YAAY,EAAE,iBAAO,CAAC,UAAU,CAAC,EAAE,CAAC,CAAA;IACvD,kBAAO,GAAG,SAAG,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,iBAAO,CAAC,UAAU,CAAC,EAAE,CAAC,CAAA;AAClE,CAAC,EAjBgB,UAAU,0BAAV,UAAU,QAiB1B"}

package/dist/cjs/Log/Entry.d.ts

@@ -1,17 +1,17 @@
-import * as z from "zod";
+import { zod } from "../zod";
 export declare namespace Entry {
-    const type: z.ZodObject<{
-        message: z.ZodString;
-        data: z.ZodOptional<z.ZodAny>;
-    }, z.core.$strip>;
+    const type: zod.ZodObject<{
+        message: zod.ZodString;
+        data: zod.ZodOptional<zod.ZodAny>;
+    }, zod.z.core.$strip>;
     namespace Message {
-        const type: z.ZodObject<{
-            resource: z.ZodOptional<z.ZodString>;
-            message: z.ZodString;
-            data: z.ZodOptional<z.ZodAny>;
-        }, z.core.$strip>;
+        const type: zod.ZodObject<{
+            resource: zod.ZodOptional<zod.ZodString>;
+            message: zod.ZodString;
+            data: zod.ZodOptional<zod.ZodAny>;
+        }, zod.z.core.$strip>;
         function to(message: string, data: any | undefined, resource: string | undefined): Entry.Message;
     }
-    type Message = z.infer<typeof Message.type>;
+    type Message = zod.infer<typeof Message.type>;
 }
-export type Entry = z.infer<typeof Entry.type>;
+export type Entry = zod.infer<typeof Entry.type>;