@sssoman/ember 0.1.0

package/dist/schemas/record-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-union.d.ts","sourceRoot":"","sources":["../../src/schemas/record-union.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,wDAAwD;AACxD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQ7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAU3B,CAAC"}

package/dist/schemas/record-union.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { assetRecordSchema } from "./asset.js";
+import { circleRecordSchema } from "./circle.js";
+import { documentRecordSchema } from "./document.js";
+import { liabilityRecordSchema } from "./liability.js";
+import { policyRecordSchema } from "./policy.js";
+import { reminderRecordSchema } from "./reminder.js";
+import { userRecordSchema } from "./user.js";
+/** Discriminated union of all domain record schemas. */
+export const hearthRecordSchema = z.discriminatedUnion("record_type", [
+    circleRecordSchema,
+    userRecordSchema,
+    policyRecordSchema,
+    assetRecordSchema,
+    liabilityRecordSchema,
+    documentRecordSchema,
+    reminderRecordSchema,
+]);
+export const RECORD_SCHEMA_BY_VERSION = {
+    1: {
+        circle: circleRecordSchema,
+        user: userRecordSchema,
+        policy: policyRecordSchema,
+        asset: assetRecordSchema,
+        liability: liabilityRecordSchema,
+        document: documentRecordSchema,
+        reminder: reminderRecordSchema,
+    },
+};
+//# sourceMappingURL=record-union.js.map

package/dist/schemas/record-union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-union.js","sourceRoot":"","sources":["../../src/schemas/record-union.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE7C,wDAAwD;AACxD,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,kBAAkB,CAAC,aAAa,EAAE;IACpE,kBAAkB;IAClB,gBAAgB;IAChB,kBAAkB;IAClB,iBAAiB;IACjB,qBAAqB;IACrB,oBAAoB;IACpB,oBAAoB;CACrB,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,CAAC,EAAE;QACD,MAAM,EAAE,kBAAkB;QAC1B,IAAI,EAAE,gBAAgB;QACtB,MAAM,EAAE,kBAAkB;QAC1B,KAAK,EAAE,iBAAiB;QACxB,SAAS,EAAE,qBAAqB;QAChC,QAAQ,EAAE,oBAAoB;QAC9B,QAAQ,EAAE,oBAAoB;KAC/B;CACO,CAAC"}

package/dist/schemas/reminder.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+export declare const REMINDER_RECURRENCE: {
+    readonly NONE: "NONE";
+    readonly DAILY: "DAILY";
+    readonly WEEKLY: "WEEKLY";
+    readonly MONTHLY: "MONTHLY";
+    readonly YEARLY: "YEARLY";
+};
+export declare const reminderRecurrenceSchema: z.ZodEnum<[string, ...string[]]>;
+export declare const reminderRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    created_by: z.ZodString;
+    circle_id: z.ZodString;
+    visibility: z.ZodEnum<[string, ...string[]]>;
+    tags: z.ZodArray<z.ZodString, "many">;
+    status: z.ZodEnum<[string, ...string[]]>;
+    record_version: z.ZodNumber;
+} & {
+    record_type: z.ZodLiteral<"reminder">;
+    schema_version: z.ZodLiteral<1>;
+    title: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+    remind_at: z.ZodString;
+    recurrence: z.ZodEnum<[string, ...string[]]>;
+    linked_record_id: z.ZodString;
+    triggered_at: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: string;
+    id: string;
+    created_at: string;
+    updated_at: string;
+    created_by: string;
+    circle_id: string;
+    visibility: string;
+    tags: string[];
+    schema_version: 1;
+    record_version: number;
+    record_type: "reminder";
+    linked_record_id: string;
+    title: string;
+    remind_at: string;
+    recurrence: string;
+    message?: string | undefined;
+    triggered_at?: string | undefined;
+}, {
+    status: string;
+    id: string;
+    created_at: string;
+    updated_at: string;
+    created_by: string;
+    circle_id: string;
+    visibility: string;
+    tags: string[];
+    schema_version: 1;
+    record_version: number;
+    record_type: "reminder";
+    linked_record_id: string;
+    title: string;
+    remind_at: string;
+    recurrence: string;
+    message?: string | undefined;
+    triggered_at?: string | undefined;
+}>;
+export type ReminderRecord = z.infer<typeof reminderRecordSchema>;
+export type ReminderRecurrence = z.infer<typeof reminderRecurrenceSchema>;
+//# sourceMappingURL=reminder.d.ts.map

package/dist/schemas/reminder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reminder.d.ts","sourceRoot":"","sources":["../../src/schemas/reminder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,mBAAmB;;;;;;CAMtB,CAAC;AAEX,eAAO,MAAM,wBAAwB,kCAEpC,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWtB,CAAC;AAEZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/schemas/reminder.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { RECORD_TYPE } from "../constants/record-type.js";
+import { SCHEMA_VERSION } from "../constants/schema-version.js";
+import { baseRecordFieldsSchema } from "./base-record.js";
+import { isoDateTimeSchema, recordIdSchema } from "./primitives.js";
+export const REMINDER_RECURRENCE = {
+    NONE: "NONE",
+    DAILY: "DAILY",
+    WEEKLY: "WEEKLY",
+    MONTHLY: "MONTHLY",
+    YEARLY: "YEARLY",
+};
+export const reminderRecurrenceSchema = z.enum(Object.values(REMINDER_RECURRENCE));
+export const reminderRecordSchema = baseRecordFieldsSchema
+    .extend({
+    record_type: z.literal(RECORD_TYPE.REMINDER),
+    schema_version: z.literal(SCHEMA_VERSION.REMINDER),
+    title: z.string().min(1).max(256),
+    message: z.string().max(2048).optional(),
+    remind_at: isoDateTimeSchema,
+    recurrence: reminderRecurrenceSchema,
+    linked_record_id: recordIdSchema,
+    triggered_at: isoDateTimeSchema.optional(),
+})
+    .strict();
+//# sourceMappingURL=reminder.js.map

package/dist/schemas/reminder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reminder.js","sourceRoot":"","sources":["../../src/schemas/reminder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEpE,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,MAAM,EAAE,QAAQ;CACR,CAAC;AAEX,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,IAAI,CAC5C,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAA0B,CAC5D,CAAC;AAEF,MAAM,CAAC,MAAM,oBAAoB,GAAG,sBAAsB;KACvD,MAAM,CAAC;IACN,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC;IAC5C,cAAc,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC;IAClD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;IACjC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE;IACxC,SAAS,EAAE,iBAAiB;IAC5B,UAAU,EAAE,wBAAwB;IACpC,gBAAgB,EAAE,cAAc;IAChC,YAAY,EAAE,iBAAiB,CAAC,QAAQ,EAAE;CAC3C,CAAC;KACD,MAAM,EAAE,CAAC"}

package/dist/schemas/user.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+export declare const userRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    created_by: z.ZodString;
+    circle_id: z.ZodString;
+    visibility: z.ZodEnum<[string, ...string[]]>;
+    tags: z.ZodArray<z.ZodString, "many">;
+    status: z.ZodEnum<[string, ...string[]]>;
+    record_version: z.ZodNumber;
+} & {
+    record_type: z.ZodLiteral<"user">;
+    schema_version: z.ZodLiteral<1>;
+    display_name: z.ZodString;
+    email: z.ZodOptional<z.ZodString>;
+    public_key: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: string;
+    id: string;
+    created_at: string;
+    updated_at: string;
+    created_by: string;
+    circle_id: string;
+    visibility: string;
+    tags: string[];
+    schema_version: 1;
+    record_version: number;
+    record_type: "user";
+    display_name: string;
+    email?: string | undefined;
+    public_key?: string | undefined;
+    locale?: string | undefined;
+}, {
+    status: string;
+    id: string;
+    created_at: string;
+    updated_at: string;
+    created_by: string;
+    circle_id: string;
+    visibility: string;
+    tags: string[];
+    schema_version: 1;
+    record_version: number;
+    record_type: "user";
+    display_name: string;
+    email?: string | undefined;
+    public_key?: string | undefined;
+    locale?: string | undefined;
+}>;
+export type UserRecord = z.infer<typeof userRecordSchema>;
+//# sourceMappingURL=user.d.ts.map

package/dist/schemas/user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/schemas/user.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASlB,CAAC;AAEZ,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/schemas/user.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { RECORD_TYPE } from "../constants/record-type.js";
+import { SCHEMA_VERSION } from "../constants/schema-version.js";
+import { baseRecordFieldsSchema } from "./base-record.js";
+export const userRecordSchema = baseRecordFieldsSchema
+    .extend({
+    record_type: z.literal(RECORD_TYPE.USER),
+    schema_version: z.literal(SCHEMA_VERSION.USER),
+    display_name: z.string().min(1).max(256),
+    email: z.string().email().optional(),
+    public_key: z.string().min(1).optional(),
+    locale: z.string().max(16).optional(),
+})
+    .strict();
+//# sourceMappingURL=user.js.map

package/dist/schemas/user.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.js","sourceRoot":"","sources":["../../src/schemas/user.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,MAAM,CAAC,MAAM,gBAAgB,GAAG,sBAAsB;KACnD,MAAM,CAAC;IACN,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC;IACxC,cAAc,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC;IAC9C,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC;IACxC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE;IACpC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IACxC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE;CACtC,CAAC;KACD,MAAM,EAAE,CAAC"}

package/dist/types/events.d.ts

@@ -0,0 +1,2 @@
+export type { EmberEvent, EmberEventPayload, EmberEventType, RecordCreatedEvent, RecordUpdatedEvent, VisibilityChangedEvent, DocumentLinkedEvent, ReminderTriggeredEvent, } from "../events/types.js";
+//# sourceMappingURL=events.d.ts.map

package/dist/types/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/types/events.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,oBAAoB,CAAC"}

package/dist/types/events.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=events.js.map

package/dist/types/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/types/events.ts"],"names":[],"mappings":""}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export type { BaseRecord, BaseRecordFields, CircleRecord, UserRecord, PolicyRecord, PolicyKind, AssetRecord, LiabilityRecord, DocumentRecord, ReminderRecord, ReminderRecurrence, HearthRecord, EncryptionMetadata, } from "./records.js";
+export type { EmberEvent, EmberEventPayload, EmberEventType, RecordCreatedEvent, RecordUpdatedEvent, VisibilityChangedEvent, DocumentLinkedEvent, ReminderTriggeredEvent, } from "./events.js";
+export type { ParseResult, ParseSuccess, ParseFailure } from "./validation.js";
+export type { Visibility, RecordStatus, RecordType, EventType, } from "../constants/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,gBAAgB,EAChB,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,UAAU,EACV,WAAW,EACX,eAAe,EACf,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,kBAAkB,GACnB,MAAM,cAAc,CAAC;AAEtB,YAAY,EACV,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/E,YAAY,EACV,UAAU,EACV,YAAY,EACZ,UAAU,EACV,SAAS,GACV,MAAM,uBAAuB,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":""}

package/dist/types/records.d.ts

@@ -0,0 +1,2 @@
+export type { BaseRecord, BaseRecordFields, CircleRecord, UserRecord, PolicyRecord, PolicyKind, AssetRecord, LiabilityRecord, DocumentRecord, ReminderRecord, ReminderRecurrence, HearthRecord, EncryptionMetadata, } from "../schemas/index.js";
+//# sourceMappingURL=records.d.ts.map

package/dist/types/records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.d.ts","sourceRoot":"","sources":["../../src/types/records.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,gBAAgB,EAChB,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,UAAU,EACV,WAAW,EACX,eAAe,EACf,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,kBAAkB,GACnB,MAAM,qBAAqB,CAAC"}

package/dist/types/records.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=records.js.map

package/dist/types/records.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.js","sourceRoot":"","sources":["../../src/types/records.ts"],"names":[],"mappings":""}

package/dist/types/validation.d.ts

@@ -0,0 +1,13 @@
+import type { z } from "zod";
+/** Successful parse result */
+export type ParseSuccess<T> = {
+    success: true;
+    data: T;
+};
+/** Failed parse result with Zod error detail */
+export type ParseFailure = {
+    success: false;
+    error: z.ZodError;
+};
+export type ParseResult<T> = ParseSuccess<T> | ParseFailure;
+//# sourceMappingURL=validation.d.ts.map

package/dist/types/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/types/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,8BAA8B;AAC9B,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI;IAC5B,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE,CAAC,CAAC;CACT,CAAC;AAEF,gDAAgD;AAChD,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,KAAK,CAAC;IACf,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC"}

package/dist/types/validation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validation.js.map

package/dist/types/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","sourceRoot":"","sources":["../../src/types/validation.ts"],"names":[],"mappings":""}

package/dist/validators/events.d.ts

@@ -0,0 +1,5 @@
+import type { EmberEventInput } from "../events/types.js";
+import type { ParseResult } from "../types/validation.js";
+export declare function validateEmberEvent(input: unknown): ParseResult<EmberEventInput>;
+export declare function validateEmberEventOrThrow(input: unknown): EmberEventInput;
+//# sourceMappingURL=events.d.ts.map

package/dist/validators/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/validators/events.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAG1D,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAAC,eAAe,CAAC,CAE/E;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAEzE"}

package/dist/validators/events.js

@@ -0,0 +1,9 @@
+import { emberEventSchema } from "../events/schemas.js";
+import { parseOrThrow, safeParse } from "./parse.js";
+export function validateEmberEvent(input) {
+    return safeParse(emberEventSchema, input);
+}
+export function validateEmberEventOrThrow(input) {
+    return parseOrThrow(emberEventSchema, input);
+}
+//# sourceMappingURL=events.js.map

package/dist/validators/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/validators/events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAGxD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAErD,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,OAAO,SAAS,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAC,KAAc;IACtD,OAAO,YAAY,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;AAC/C,CAAC"}

package/dist/validators/index.d.ts

@@ -0,0 +1,5 @@
+export { safeParse, parseOrThrow } from "./parse.js";
+export { validateHearthRecord, validateHearthRecordOrThrow, validateRecordByType, validateCircleRecord, validateUserRecord, validatePolicyRecord, validateAssetRecord, validateLiabilityRecord, validateDocumentRecord, validateReminderRecord, } from "./records.js";
+export { validateEmberEvent, validateEmberEventOrThrow, } from "./events.js";
+export { getCurrentSchemaVersion, isSupportedSchemaVersion, validateRecordAtVersion, } from "./schema-version.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/validators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAErD,OAAO,EACL,oBAAoB,EACpB,2BAA2B,EAC3B,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,kBAAkB,EAClB,yBAAyB,GAC1B,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,qBAAqB,CAAC"}

package/dist/validators/index.js

@@ -0,0 +1,5 @@
+export { safeParse, parseOrThrow } from "./parse.js";
+export { validateHearthRecord, validateHearthRecordOrThrow, validateRecordByType, validateCircleRecord, validateUserRecord, validatePolicyRecord, validateAssetRecord, validateLiabilityRecord, validateDocumentRecord, validateReminderRecord, } from "./records.js";
+export { validateEmberEvent, validateEmberEventOrThrow, } from "./events.js";
+export { getCurrentSchemaVersion, isSupportedSchemaVersion, validateRecordAtVersion, } from "./schema-version.js";
+//# sourceMappingURL=index.js.map

package/dist/validators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/validators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAErD,OAAO,EACL,oBAAoB,EACpB,2BAA2B,EAC3B,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,kBAAkB,EAClB,yBAAyB,GAC1B,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,uBAAuB,GACxB,MAAM,qBAAqB,CAAC"}

package/dist/validators/parse.d.ts

@@ -0,0 +1,5 @@
+import type { z } from "zod";
+import type { ParseResult } from "../types/validation.js";
+export declare function safeParse<T>(schema: z.ZodTypeAny, input: unknown): ParseResult<T>;
+export declare function parseOrThrow<T>(schema: z.ZodType<T>, input: unknown): T;
+//# sourceMappingURL=parse.d.ts.map

package/dist/validators/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/validators/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,UAAU,EAAE,KAAK,EAAE,OAAO,GAAG,WAAW,CAAC,CAAC,CAAC,CAMjF;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,CAEvE"}

package/dist/validators/parse.js

@@ -0,0 +1,11 @@
+export function safeParse(schema, input) {
+    const result = schema.safeParse(input);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    return { success: false, error: result.error };
+}
+export function parseOrThrow(schema, input) {
+    return schema.parse(input);
+}
+//# sourceMappingURL=parse.js.map

package/dist/validators/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../src/validators/parse.ts"],"names":[],"mappings":"AAIA,MAAM,UAAU,SAAS,CAAI,MAAoB,EAAE,KAAc;IAC/D,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACvC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC;IAC9C,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,YAAY,CAAI,MAAoB,EAAE,KAAc;IAClE,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;AAC7B,CAAC"}

package/dist/validators/records.d.ts

@@ -0,0 +1,16 @@
+import { type RecordType } from "../constants/record-type.js";
+import type { AssetRecord, CircleRecord, DocumentRecord, HearthRecord, LiabilityRecord, PolicyRecord, ReminderRecord, UserRecord } from "../types/records.js";
+import type { ParseResult } from "../types/validation.js";
+export declare function validateHearthRecord(input: unknown): ParseResult<HearthRecord>;
+export declare function validateHearthRecordOrThrow(input: unknown): HearthRecord;
+export declare function validateRecordByType<T extends RecordType>(recordType: T, input: unknown): ParseResult<Extract<HearthRecord, {
+    record_type: T;
+}>>;
+export declare function validateCircleRecord(input: unknown): ParseResult<CircleRecord>;
+export declare function validateUserRecord(input: unknown): ParseResult<UserRecord>;
+export declare function validatePolicyRecord(input: unknown): ParseResult<PolicyRecord>;
+export declare function validateAssetRecord(input: unknown): ParseResult<AssetRecord>;
+export declare function validateLiabilityRecord(input: unknown): ParseResult<LiabilityRecord>;
+export declare function validateDocumentRecord(input: unknown): ParseResult<DocumentRecord>;
+export declare function validateReminderRecord(input: unknown): ParseResult<ReminderRecord>;
+//# sourceMappingURL=records.d.ts.map

package/dist/validators/records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.d.ts","sourceRoot":"","sources":["../../src/validators/records.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAW3E,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,cAAc,EACd,UAAU,EACX,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAa1D,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAAC,YAAY,CAAC,CAE9E;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAExE;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,UAAU,EACvD,UAAU,EAAE,CAAC,EACb,KAAK,EAAE,OAAO,GACb,WAAW,CAAC,OAAO,CAAC,YAAY,EAAE;IAAE,WAAW,EAAE,CAAC,CAAA;CAAE,CAAC,CAAC,CAGxD;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAAC,YAAY,CAAC,CAE9E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAAC,UAAU,CAAC,CAE1E;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAAC,YAAY,CAAC,CAE9E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAAC,WAAW,CAAC,CAE5E;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,OAAO,GACb,WAAW,CAAC,eAAe,CAAC,CAE9B;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,GACb,WAAW,CAAC,cAAc,CAAC,CAE7B;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,GACb,WAAW,CAAC,cAAc,CAAC,CAE7B"}

package/dist/validators/records.js

@@ -0,0 +1,44 @@
+import { RECORD_TYPE } from "../constants/record-type.js";
+import { assetRecordSchema, circleRecordSchema, documentRecordSchema, hearthRecordSchema, liabilityRecordSchema, policyRecordSchema, reminderRecordSchema, userRecordSchema, } from "../schemas/index.js";
+import { parseOrThrow, safeParse } from "./parse.js";
+const schemaByRecordType = {
+    [RECORD_TYPE.CIRCLE]: circleRecordSchema,
+    [RECORD_TYPE.USER]: userRecordSchema,
+    [RECORD_TYPE.POLICY]: policyRecordSchema,
+    [RECORD_TYPE.ASSET]: assetRecordSchema,
+    [RECORD_TYPE.LIABILITY]: liabilityRecordSchema,
+    [RECORD_TYPE.DOCUMENT]: documentRecordSchema,
+    [RECORD_TYPE.REMINDER]: reminderRecordSchema,
+};
+export function validateHearthRecord(input) {
+    return safeParse(hearthRecordSchema, input);
+}
+export function validateHearthRecordOrThrow(input) {
+    return parseOrThrow(hearthRecordSchema, input);
+}
+export function validateRecordByType(recordType, input) {
+    const result = safeParse(schemaByRecordType[recordType], input);
+    return result;
+}
+export function validateCircleRecord(input) {
+    return safeParse(circleRecordSchema, input);
+}
+export function validateUserRecord(input) {
+    return safeParse(userRecordSchema, input);
+}
+export function validatePolicyRecord(input) {
+    return safeParse(policyRecordSchema, input);
+}
+export function validateAssetRecord(input) {
+    return safeParse(assetRecordSchema, input);
+}
+export function validateLiabilityRecord(input) {
+    return safeParse(liabilityRecordSchema, input);
+}
+export function validateDocumentRecord(input) {
+    return safeParse(documentRecordSchema, input);
+}
+export function validateReminderRecord(input) {
+    return safeParse(reminderRecordSchema, input);
+}
+//# sourceMappingURL=records.js.map

package/dist/validators/records.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"records.js","sourceRoot":"","sources":["../../src/validators/records.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAmB,MAAM,6BAA6B,CAAC;AAC3E,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,qBAAqB,CAAC;AAY7B,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAErD,MAAM,kBAAkB,GAAG;IACzB,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,kBAAkB;IACxC,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,gBAAgB;IACpC,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,kBAAkB;IACxC,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,iBAAiB;IACtC,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,qBAAqB;IAC9C,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,oBAAoB;IAC5C,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,oBAAoB;CACF,CAAC;AAE7C,MAAM,UAAU,oBAAoB,CAAC,KAAc;IACjD,OAAO,SAAS,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;AAC9C,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAC,KAAc;IACxD,OAAO,YAAY,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,oBAAoB,CAClC,UAAa,EACb,KAAc;IAEd,MAAM,MAAM,GAAG,SAAS,CAAC,kBAAkB,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC,CAAC;IAChE,OAAO,MAAgE,CAAC;AAC1E,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,KAAc;IACjD,OAAO,SAAS,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;AAC9C,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,OAAO,SAAS,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,KAAc;IACjD,OAAO,SAAS,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;AAC9C,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,KAAc;IAChD,OAAO,SAAS,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,uBAAuB,CACrC,KAAc;IAEd,OAAO,SAAS,CAAC,qBAAqB,EAAE,KAAK,CAAC,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,sBAAsB,CACpC,KAAc;IAEd,OAAO,SAAS,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;AAChD,CAAC;AAED,MAAM,UAAU,sBAAsB,CACpC,KAAc;IAEd,OAAO,SAAS,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;AAChD,CAAC"}

package/dist/validators/schema-version.d.ts

@@ -0,0 +1,11 @@
+import { type RecordType } from "../constants/record-type.js";
+import type { HearthRecord } from "../types/records.js";
+import type { ParseResult } from "../types/validation.js";
+export declare function getCurrentSchemaVersion(recordType: RecordType): number;
+export declare function isSupportedSchemaVersion(recordType: RecordType, version: number): boolean;
+/**
+ * Validates a record against the schema registry for its declared version.
+ * When migrating, register additional versions in RECORD_SCHEMA_BY_VERSION.
+ */
+export declare function validateRecordAtVersion(recordType: RecordType, schemaVersion: number, input: unknown): ParseResult<HearthRecord>;
+//# sourceMappingURL=schema-version.d.ts.map

package/dist/validators/schema-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-version.d.ts","sourceRoot":"","sources":["../../src/validators/schema-version.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,KAAK,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAM3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AA0B1D,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAGtE;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,MAAM,GACd,OAAO,CAET;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,OAAO,GACb,WAAW,CAAC,YAAY,CAAC,CAqB3B"}

package/dist/validators/schema-version.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { RECORD_TYPE } from "../constants/record-type.js";
+import { SCHEMA_VERSION, } from "../constants/schema-version.js";
+import { RECORD_SCHEMA_BY_VERSION } from "../schemas/record-union.js";
+import { safeParse } from "./parse.js";
+const recordTypeToSchemaKey = {
+    [RECORD_TYPE.CIRCLE]: "circle",
+    [RECORD_TYPE.USER]: "user",
+    [RECORD_TYPE.POLICY]: "policy",
+    [RECORD_TYPE.ASSET]: "asset",
+    [RECORD_TYPE.LIABILITY]: "liability",
+    [RECORD_TYPE.DOCUMENT]: "document",
+    [RECORD_TYPE.REMINDER]: "reminder",
+};
+const recordTypeToVersionKey = {
+    [RECORD_TYPE.CIRCLE]: "CIRCLE",
+    [RECORD_TYPE.USER]: "USER",
+    [RECORD_TYPE.POLICY]: "POLICY",
+    [RECORD_TYPE.ASSET]: "ASSET",
+    [RECORD_TYPE.LIABILITY]: "LIABILITY",
+    [RECORD_TYPE.DOCUMENT]: "DOCUMENT",
+    [RECORD_TYPE.REMINDER]: "REMINDER",
+};
+export function getCurrentSchemaVersion(recordType) {
+    const key = recordTypeToVersionKey[recordType];
+    return SCHEMA_VERSION[key];
+}
+export function isSupportedSchemaVersion(recordType, version) {
+    return version === getCurrentSchemaVersion(recordType);
+}
+/**
+ * Validates a record against the schema registry for its declared version.
+ * When migrating, register additional versions in RECORD_SCHEMA_BY_VERSION.
+ */
+export function validateRecordAtVersion(recordType, schemaVersion, input) {
+    const versionMap = RECORD_SCHEMA_BY_VERSION[schemaVersion];
+    if (!versionMap) {
+        return {
+            success: false,
+            error: new z.ZodError([
+                {
+                    code: z.ZodIssueCode.custom,
+                    message: `Unsupported schema_version: ${schemaVersion}`,
+                    path: ["schema_version"],
+                },
+            ]),
+        };
+    }
+    const schemaKey = recordTypeToSchemaKey[recordType];
+    const schema = versionMap[schemaKey];
+    return safeParse(schema, input);
+}
+//# sourceMappingURL=schema-version.js.map

package/dist/validators/schema-version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-version.js","sourceRoot":"","sources":["../../src/validators/schema-version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,WAAW,EAAmB,MAAM,6BAA6B,CAAC;AAC3E,OAAO,EACL,cAAc,GAEf,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAGtE,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,qBAAqB,GAGvB;IACF,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,QAAQ;IAC9B,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,MAAM;IAC1B,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,QAAQ;IAC9B,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,OAAO;IAC5B,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,WAAW;IACpC,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,UAAU;IAClC,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,UAAU;CACnC,CAAC;AAEF,MAAM,sBAAsB,GAAyC;IACnE,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,QAAQ;IAC9B,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,MAAM;IAC1B,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,QAAQ;IAC9B,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,OAAO;IAC5B,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,WAAW;IACpC,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,UAAU;IAClC,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,UAAU;CACnC,CAAC;AAEF,MAAM,UAAU,uBAAuB,CAAC,UAAsB;IAC5D,MAAM,GAAG,GAAG,sBAAsB,CAAC,UAAU,CAAC,CAAC;IAC/C,OAAO,cAAc,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED,MAAM,UAAU,wBAAwB,CACtC,UAAsB,EACtB,OAAe;IAEf,OAAO,OAAO,KAAK,uBAAuB,CAAC,UAAU,CAAC,CAAC;AACzD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CACrC,UAAsB,EACtB,aAAqB,EACrB,KAAc;IAEd,MAAM,UAAU,GACd,wBAAwB,CACtB,aAAsD,CACvD,CAAC;IACJ,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO;YACL,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC;gBACpB;oBACE,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM;oBAC3B,OAAO,EAAE,+BAA+B,aAAa,EAAE;oBACvD,IAAI,EAAE,CAAC,gBAAgB,CAAC;iBACzB;aACF,CAAC;SACH,CAAC;IACJ,CAAC;IAED,MAAM,SAAS,GAAG,qBAAqB,CAAC,UAAU,CAAC,CAAC;IACpD,MAAM,MAAM,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC;IACrC,OAAO,SAAS,CAAC,MAAiC,EAAE,KAAK,CAAC,CAAC;AAC7D,CAAC"}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@sssoman/ember",
+  "version": "0.1.0",
+  "description": "Canonical schema and domain layer for the Hearth local-first encrypted records ecosystem",
+  "author": "sarweshsoman",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./schemas": {
+      "types": "./dist/schemas/index.d.ts",
+      "import": "./dist/schemas/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js"
+    },
+    "./events": {
+      "types": "./dist/events/index.d.ts",
+      "import": "./dist/events/index.js"
+    },
+    "./validators": {
+      "types": "./dist/validators/index.d.ts",
+      "import": "./dist/validators/index.js"
+    },
+    "./constants": {
+      "types": "./dist/constants/index.d.ts",
+      "import": "./dist/constants/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "generate:json-schema": "tsx scripts/generate-json-schema.ts",
+    "prepack": "pnpm run build",
+    "prepublishOnly": "pnpm run typecheck && pnpm run build",
+    "pack:check": "npm pack --dry-run"
+  },
+  "keywords": [
+    "hearth",
+    "ember",
+    "schema",
+    "records",
+    "local-first",
+    "zod"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@9.15.0",
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "zod-to-json-schema": "^3.24.5"
+  },
+  "dependencies": {
+    "zod": "^3.25.28"
+  },
+  "peerDependencies": {
+    "zod": "^3.25.0"
+  }
+}