@objectstack/spec 0.1.0 → 0.1.1

package/dist/system/policy.zod.d.ts

@@ -0,0 +1,209 @@
+import { z } from 'zod';
+/**
+ * Password Complexity Policy
+ */
+export declare const PasswordPolicySchema: z.ZodObject<{
+    minLength: z.ZodDefault<z.ZodNumber>;
+    requireUppercase: z.ZodDefault<z.ZodBoolean>;
+    requireLowercase: z.ZodDefault<z.ZodBoolean>;
+    requireNumbers: z.ZodDefault<z.ZodBoolean>;
+    requireSymbols: z.ZodDefault<z.ZodBoolean>;
+    expirationDays: z.ZodOptional<z.ZodNumber>;
+    historyCount: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    minLength: number;
+    requireUppercase: boolean;
+    requireLowercase: boolean;
+    requireNumbers: boolean;
+    requireSymbols: boolean;
+    historyCount: number;
+    expirationDays?: number | undefined;
+}, {
+    minLength?: number | undefined;
+    requireUppercase?: boolean | undefined;
+    requireLowercase?: boolean | undefined;
+    requireNumbers?: boolean | undefined;
+    requireSymbols?: boolean | undefined;
+    expirationDays?: number | undefined;
+    historyCount?: number | undefined;
+}>;
+/**
+ * Network Access Policy (IP Whitelisting)
+ */
+export declare const NetworkPolicySchema: z.ZodObject<{
+    trustedRanges: z.ZodArray<z.ZodString, "many">;
+    blockUnknown: z.ZodDefault<z.ZodBoolean>;
+    vpnRequired: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    trustedRanges: string[];
+    blockUnknown: boolean;
+    vpnRequired: boolean;
+}, {
+    trustedRanges: string[];
+    blockUnknown?: boolean | undefined;
+    vpnRequired?: boolean | undefined;
+}>;
+/**
+ * Session Policy
+ */
+export declare const SessionPolicySchema: z.ZodObject<{
+    idleTimeout: z.ZodDefault<z.ZodNumber>;
+    absoluteTimeout: z.ZodDefault<z.ZodNumber>;
+    forceMfa: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    idleTimeout: number;
+    absoluteTimeout: number;
+    forceMfa: boolean;
+}, {
+    idleTimeout?: number | undefined;
+    absoluteTimeout?: number | undefined;
+    forceMfa?: boolean | undefined;
+}>;
+/**
+ * Audit Retention Policy
+ */
+export declare const AuditPolicySchema: z.ZodObject<{
+    logRetentionDays: z.ZodDefault<z.ZodNumber>;
+    sensitiveFields: z.ZodArray<z.ZodString, "many">;
+    captureRead: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    logRetentionDays: number;
+    sensitiveFields: string[];
+    captureRead: boolean;
+}, {
+    sensitiveFields: string[];
+    logRetentionDays?: number | undefined;
+    captureRead?: boolean | undefined;
+}>;
+/**
+ * Security Policy Schema
+ * "The Cloud Compliance Contract"
+ */
+export declare const PolicySchema: z.ZodObject<{
+    name: z.ZodString;
+    password: z.ZodOptional<z.ZodObject<{
+        minLength: z.ZodDefault<z.ZodNumber>;
+        requireUppercase: z.ZodDefault<z.ZodBoolean>;
+        requireLowercase: z.ZodDefault<z.ZodBoolean>;
+        requireNumbers: z.ZodDefault<z.ZodBoolean>;
+        requireSymbols: z.ZodDefault<z.ZodBoolean>;
+        expirationDays: z.ZodOptional<z.ZodNumber>;
+        historyCount: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        minLength: number;
+        requireUppercase: boolean;
+        requireLowercase: boolean;
+        requireNumbers: boolean;
+        requireSymbols: boolean;
+        historyCount: number;
+        expirationDays?: number | undefined;
+    }, {
+        minLength?: number | undefined;
+        requireUppercase?: boolean | undefined;
+        requireLowercase?: boolean | undefined;
+        requireNumbers?: boolean | undefined;
+        requireSymbols?: boolean | undefined;
+        expirationDays?: number | undefined;
+        historyCount?: number | undefined;
+    }>>;
+    network: z.ZodOptional<z.ZodObject<{
+        trustedRanges: z.ZodArray<z.ZodString, "many">;
+        blockUnknown: z.ZodDefault<z.ZodBoolean>;
+        vpnRequired: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        trustedRanges: string[];
+        blockUnknown: boolean;
+        vpnRequired: boolean;
+    }, {
+        trustedRanges: string[];
+        blockUnknown?: boolean | undefined;
+        vpnRequired?: boolean | undefined;
+    }>>;
+    session: z.ZodOptional<z.ZodObject<{
+        idleTimeout: z.ZodDefault<z.ZodNumber>;
+        absoluteTimeout: z.ZodDefault<z.ZodNumber>;
+        forceMfa: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        idleTimeout: number;
+        absoluteTimeout: number;
+        forceMfa: boolean;
+    }, {
+        idleTimeout?: number | undefined;
+        absoluteTimeout?: number | undefined;
+        forceMfa?: boolean | undefined;
+    }>>;
+    audit: z.ZodOptional<z.ZodObject<{
+        logRetentionDays: z.ZodDefault<z.ZodNumber>;
+        sensitiveFields: z.ZodArray<z.ZodString, "many">;
+        captureRead: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        logRetentionDays: number;
+        sensitiveFields: string[];
+        captureRead: boolean;
+    }, {
+        sensitiveFields: string[];
+        logRetentionDays?: number | undefined;
+        captureRead?: boolean | undefined;
+    }>>;
+    /** Assignment */
+    isDefault: z.ZodDefault<z.ZodBoolean>;
+    assignedProfiles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    isDefault: boolean;
+    password?: {
+        minLength: number;
+        requireUppercase: boolean;
+        requireLowercase: boolean;
+        requireNumbers: boolean;
+        requireSymbols: boolean;
+        historyCount: number;
+        expirationDays?: number | undefined;
+    } | undefined;
+    assignedProfiles?: string[] | undefined;
+    network?: {
+        trustedRanges: string[];
+        blockUnknown: boolean;
+        vpnRequired: boolean;
+    } | undefined;
+    session?: {
+        idleTimeout: number;
+        absoluteTimeout: number;
+        forceMfa: boolean;
+    } | undefined;
+    audit?: {
+        logRetentionDays: number;
+        sensitiveFields: string[];
+        captureRead: boolean;
+    } | undefined;
+}, {
+    name: string;
+    password?: {
+        minLength?: number | undefined;
+        requireUppercase?: boolean | undefined;
+        requireLowercase?: boolean | undefined;
+        requireNumbers?: boolean | undefined;
+        requireSymbols?: boolean | undefined;
+        expirationDays?: number | undefined;
+        historyCount?: number | undefined;
+    } | undefined;
+    isDefault?: boolean | undefined;
+    assignedProfiles?: string[] | undefined;
+    network?: {
+        trustedRanges: string[];
+        blockUnknown?: boolean | undefined;
+        vpnRequired?: boolean | undefined;
+    } | undefined;
+    session?: {
+        idleTimeout?: number | undefined;
+        absoluteTimeout?: number | undefined;
+        forceMfa?: boolean | undefined;
+    } | undefined;
+    audit?: {
+        sensitiveFields: string[];
+        logRetentionDays?: number | undefined;
+        captureRead?: boolean | undefined;
+    } | undefined;
+}>;
+export type Policy = z.infer<typeof PolicySchema>;
+//# sourceMappingURL=policy.zod.d.ts.map

package/dist/system/policy.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.zod.d.ts","sourceRoot":"","sources":["../../src/system/policy.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;EAQ/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAI9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAI9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAI5B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQvB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/system/policy.zod.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicySchema = exports.AuditPolicySchema = exports.SessionPolicySchema = exports.NetworkPolicySchema = exports.PasswordPolicySchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Password Complexity Policy
+ */
+exports.PasswordPolicySchema = zod_1.z.object({
+    minLength: zod_1.z.number().default(8),
+    requireUppercase: zod_1.z.boolean().default(true),
+    requireLowercase: zod_1.z.boolean().default(true),
+    requireNumbers: zod_1.z.boolean().default(true),
+    requireSymbols: zod_1.z.boolean().default(false),
+    expirationDays: zod_1.z.number().optional().describe('Force password change every X days'),
+    historyCount: zod_1.z.number().default(3).describe('Prevent reusing last X passwords'),
+});
+/**
+ * Network Access Policy (IP Whitelisting)
+ */
+exports.NetworkPolicySchema = zod_1.z.object({
+    trustedRanges: zod_1.z.array(zod_1.z.string()).describe('CIDR ranges allowed to access (e.g. 10.0.0.0/8)'),
+    blockUnknown: zod_1.z.boolean().default(false).describe('Block all IPs not in trusted ranges'),
+    vpnRequired: zod_1.z.boolean().default(false),
+});
+/**
+ * Session Policy
+ */
+exports.SessionPolicySchema = zod_1.z.object({
+    idleTimeout: zod_1.z.number().default(30).describe('Minutes before idle session logout'),
+    absoluteTimeout: zod_1.z.number().default(480).describe('Max session duration (minutes)'),
+    forceMfa: zod_1.z.boolean().default(false).describe('Require 2FA for all users'),
+});
+/**
+ * Audit Retention Policy
+ */
+exports.AuditPolicySchema = zod_1.z.object({
+    logRetentionDays: zod_1.z.number().default(180),
+    sensitiveFields: zod_1.z.array(zod_1.z.string()).describe('Fields to redact in logs (e.g. password, ssn)'),
+    captureRead: zod_1.z.boolean().default(false).describe('Log read access (High volume!)'),
+});
+/**
+ * Security Policy Schema
+ * "The Cloud Compliance Contract"
+ */
+exports.PolicySchema = zod_1.z.object({
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Policy Name'),
+    password: exports.PasswordPolicySchema.optional(),
+    network: exports.NetworkPolicySchema.optional(),
+    session: exports.SessionPolicySchema.optional(),
+    audit: exports.AuditPolicySchema.optional(),
+    /** Assignment */
+    isDefault: zod_1.z.boolean().default(false).describe('Apply to all users by default'),
+    assignedProfiles: zod_1.z.array(zod_1.z.string()).optional().describe('Apply to specific profiles'),
+});

package/dist/system/role.zod.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+/**
+ * Role Schema (aka Business Unit / Org Unit)
+ * Defines the organizational hierarchy (Reporting Structure).
+ *
+ * COMPARISON:
+ * - Salesforce: "Role" (Hierarchy for visibility rollup)
+ * - Microsoft: "Business Unit" (Structural container for data)
+ * - Kubernetes/AWS: "Role" usually refers to Permissions (we use PermissionSet for that)
+ *
+ * ROLES IN OBJECTSTACK:
+ * Used primarily for "Reporting Structure" - Managers see subordinates' data.
+ */
+export declare const RoleSchema: z.ZodObject<{
+    /** Identity */
+    name: z.ZodString;
+    label: z.ZodString;
+    /** Hierarchy */
+    parent: z.ZodOptional<z.ZodString>;
+    /** Description */
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    name: string;
+    description?: string | undefined;
+    parent?: string | undefined;
+}, {
+    label: string;
+    name: string;
+    description?: string | undefined;
+    parent?: string | undefined;
+}>;
+export type Role = z.infer<typeof RoleSchema>;
+//# sourceMappingURL=role.zod.d.ts.map

package/dist/system/role.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"role.zod.d.ts","sourceRoot":"","sources":["../../src/system/role.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU;IACrB,eAAe;;;IAIf,gBAAgB;;IAGhB,kBAAkB;;;;;;;;;;;;EAElB,CAAC;AAEH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/system/role.zod.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoleSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Role Schema (aka Business Unit / Org Unit)
+ * Defines the organizational hierarchy (Reporting Structure).
+ *
+ * COMPARISON:
+ * - Salesforce: "Role" (Hierarchy for visibility rollup)
+ * - Microsoft: "Business Unit" (Structural container for data)
+ * - Kubernetes/AWS: "Role" usually refers to Permissions (we use PermissionSet for that)
+ *
+ * ROLES IN OBJECTSTACK:
+ * Used primarily for "Reporting Structure" - Managers see subordinates' data.
+ */
+exports.RoleSchema = zod_1.z.object({
+    /** Identity */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Unique role name'),
+    label: zod_1.z.string().describe('Display label (e.g. VP of Sales)'),
+    /** Hierarchy */
+    parent: zod_1.z.string().optional().describe('Parent Role ID (Reports To)'),
+    /** Description */
+    description: zod_1.z.string().optional(),
+});

package/dist/system/territory.zod.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+/**
+ * Territory Management Protocol
+ * Defines a matrix reporting structure that exists parallel to the Role Hierarchy.
+ *
+ * USE CASE:
+ * - Enterprise Sales Teams (Geo-based: "EMEA", "APAC")
+ * - Industry Verticals (Industry-based: "Healthcare", "Financial")
+ * - Strategic Accounts (Account-based: "Strategic Accounts")
+ *
+ * DIFFERENCE FROM ROLE:
+ * - Role: Hierarchy of PEOPLE (Who reports to whom). Stable. HR-driven.
+ * - Territory: Hierarchy of ACCOUNTS/REVENUE (Who owns which market). Flexible. Sales-driven.
+ * - One User can be assigned to MANY Territories (Matrix).
+ * - One User has only ONE Role (Tree).
+ */
+export declare const TerritoryType: z.ZodEnum<["geography", "industry", "named_account", "product_line"]>;
+/**
+ * Territory Model Schema
+ * A container for a version of territory planning.
+ * (e.g. "Fiscal Year 2024 Planning" vs "Fiscal Year 2025 Planning")
+ */
+export declare const TerritoryModelSchema: z.ZodObject<{
+    name: z.ZodString;
+    state: z.ZodDefault<z.ZodEnum<["planning", "active", "archived"]>>;
+    startDate: z.ZodOptional<z.ZodString>;
+    endDate: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    state: "active" | "planning" | "archived";
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+}, {
+    name: string;
+    state?: "active" | "planning" | "archived" | undefined;
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+}>;
+/**
+ * Territory Node Schema
+ * A single node in the territory tree.
+ */
+export declare const TerritorySchema: z.ZodObject<{
+    /** Identity */
+    name: z.ZodString;
+    label: z.ZodString;
+    /** Structure */
+    modelId: z.ZodString;
+    parent: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<["geography", "industry", "named_account", "product_line"]>>;
+    /**
+     * Assignment Rules (The "Magic")
+     * How do accounts automatically fall into this territory?
+     * e.g. "BillingCountry = 'US' AND BillingState = 'CA'"
+     */
+    assignmentRule: z.ZodOptional<z.ZodString>;
+    /**
+     * User Assignment
+     * Users assigned to work this territory.
+     */
+    assignedUsers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Access Level */
+    accountAccess: z.ZodDefault<z.ZodEnum<["read", "edit"]>>;
+    opportunityAccess: z.ZodDefault<z.ZodEnum<["read", "edit"]>>;
+    caseAccess: z.ZodDefault<z.ZodEnum<["read", "edit"]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "geography" | "industry" | "named_account" | "product_line";
+    label: string;
+    name: string;
+    modelId: string;
+    accountAccess: "read" | "edit";
+    opportunityAccess: "read" | "edit";
+    caseAccess: "read" | "edit";
+    parent?: string | undefined;
+    assignmentRule?: string | undefined;
+    assignedUsers?: string[] | undefined;
+}, {
+    label: string;
+    name: string;
+    modelId: string;
+    type?: "geography" | "industry" | "named_account" | "product_line" | undefined;
+    parent?: string | undefined;
+    assignmentRule?: string | undefined;
+    assignedUsers?: string[] | undefined;
+    accountAccess?: "read" | "edit" | undefined;
+    opportunityAccess?: "read" | "edit" | undefined;
+    caseAccess?: "read" | "edit" | undefined;
+}>;
+export type Territory = z.infer<typeof TerritorySchema>;
+export type TerritoryModel = z.infer<typeof TerritoryModelSchema>;
+//# sourceMappingURL=territory.zod.d.ts.map

package/dist/system/territory.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"territory.zod.d.ts","sourceRoot":"","sources":["../../src/system/territory.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,aAAa,uEAKxB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAK/B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B,eAAe;;;IAIf,gBAAgB;;;;IAKhB;;;;OAIG;;IAGH;;;OAGG;;IAGH,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;EAInB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/system/territory.zod.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerritorySchema = exports.TerritoryModelSchema = exports.TerritoryType = void 0;
+const zod_1 = require("zod");
+/**
+ * Territory Management Protocol
+ * Defines a matrix reporting structure that exists parallel to the Role Hierarchy.
+ *
+ * USE CASE:
+ * - Enterprise Sales Teams (Geo-based: "EMEA", "APAC")
+ * - Industry Verticals (Industry-based: "Healthcare", "Financial")
+ * - Strategic Accounts (Account-based: "Strategic Accounts")
+ *
+ * DIFFERENCE FROM ROLE:
+ * - Role: Hierarchy of PEOPLE (Who reports to whom). Stable. HR-driven.
+ * - Territory: Hierarchy of ACCOUNTS/REVENUE (Who owns which market). Flexible. Sales-driven.
+ * - One User can be assigned to MANY Territories (Matrix).
+ * - One User has only ONE Role (Tree).
+ */
+exports.TerritoryType = zod_1.z.enum([
+    'geography', // Region/Country/City
+    'industry', // Vertical
+    'named_account', // Key Accounts
+    'product_line' // Product Specialty
+]);
+/**
+ * Territory Model Schema
+ * A container for a version of territory planning.
+ * (e.g. "Fiscal Year 2024 Planning" vs "Fiscal Year 2025 Planning")
+ */
+exports.TerritoryModelSchema = zod_1.z.object({
+    name: zod_1.z.string().describe('Model Name (e.g. FY24 Planning)'),
+    state: zod_1.z.enum(['planning', 'active', 'archived']).default('planning'),
+    startDate: zod_1.z.string().optional(),
+    endDate: zod_1.z.string().optional(),
+});
+/**
+ * Territory Node Schema
+ * A single node in the territory tree.
+ */
+exports.TerritorySchema = zod_1.z.object({
+    /** Identity */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/),
+    label: zod_1.z.string().describe('Territory Label (e.g. "West Coast")'),
+    /** Structure */
+    modelId: zod_1.z.string().describe('Belongs to which Territory Model'),
+    parent: zod_1.z.string().optional().describe('Parent Territory'),
+    type: exports.TerritoryType.default('geography'),
+    /**
+     * Assignment Rules (The "Magic")
+     * How do accounts automatically fall into this territory?
+     * e.g. "BillingCountry = 'US' AND BillingState = 'CA'"
+     */
+    assignmentRule: zod_1.z.string().optional().describe('Criteria based assignment rule'),
+    /**
+     * User Assignment
+     * Users assigned to work this territory.
+     */
+    assignedUsers: zod_1.z.array(zod_1.z.string()).optional(),
+    /** Access Level */
+    accountAccess: zod_1.z.enum(['read', 'edit']).default('read'),
+    opportunityAccess: zod_1.z.enum(['read', 'edit']).default('read'),
+    caseAccess: zod_1.z.enum(['read', 'edit']).default('read'),
+});

package/dist/system/translation.zod.d.ts

@@ -0,0 +1,171 @@
+import { z } from 'zod';
+/**
+ * Translation Schema
+ * Supports i18n for labels, messages, and options.
+ * Example structure:
+ * {
+ *   "en": { "objects": { "account": { "label": "Account" } } },
+ *   "zh-CN": { "objects": { "account": { "label": "客户" } } }
+ * }
+ */
+export declare const TranslationDataSchema: z.ZodObject<{
+    /** Object translations */
+    objects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+        pluralLabel: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            help: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            options?: Record<string, string> | undefined;
+            label?: string | undefined;
+            help?: string | undefined;
+        }, {
+            options?: Record<string, string> | undefined;
+            label?: string | undefined;
+            help?: string | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        fields?: Record<string, {
+            options?: Record<string, string> | undefined;
+            label?: string | undefined;
+            help?: string | undefined;
+        }> | undefined;
+        pluralLabel?: string | undefined;
+    }, {
+        label: string;
+        fields?: Record<string, {
+            options?: Record<string, string> | undefined;
+            label?: string | undefined;
+            help?: string | undefined;
+        }> | undefined;
+        pluralLabel?: string | undefined;
+    }>>>;
+    /** App/Menu translations */
+    apps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        description?: string | undefined;
+    }, {
+        label: string;
+        description?: string | undefined;
+    }>>>;
+    /** UI Messages */
+    messages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    objects?: Record<string, {
+        label: string;
+        fields?: Record<string, {
+            options?: Record<string, string> | undefined;
+            label?: string | undefined;
+            help?: string | undefined;
+        }> | undefined;
+        pluralLabel?: string | undefined;
+    }> | undefined;
+    apps?: Record<string, {
+        label: string;
+        description?: string | undefined;
+    }> | undefined;
+    messages?: Record<string, string> | undefined;
+}, {
+    objects?: Record<string, {
+        label: string;
+        fields?: Record<string, {
+            options?: Record<string, string> | undefined;
+            label?: string | undefined;
+            help?: string | undefined;
+        }> | undefined;
+        pluralLabel?: string | undefined;
+    }> | undefined;
+    apps?: Record<string, {
+        label: string;
+        description?: string | undefined;
+    }> | undefined;
+    messages?: Record<string, string> | undefined;
+}>;
+export declare const LocaleSchema: z.ZodString;
+export declare const TranslationBundleSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    /** Object translations */
+    objects: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+        pluralLabel: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            help: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            options?: Record<string, string> | undefined;
+            label?: string | undefined;
+            help?: string | undefined;
+        }, {
+            options?: Record<string, string> | undefined;
+            label?: string | undefined;
+            help?: string | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        fields?: Record<string, {
+            options?: Record<string, string> | undefined;
+            label?: string | undefined;
+            help?: string | undefined;
+        }> | undefined;
+        pluralLabel?: string | undefined;
+    }, {
+        label: string;
+        fields?: Record<string, {
+            options?: Record<string, string> | undefined;
+            label?: string | undefined;
+            help?: string | undefined;
+        }> | undefined;
+        pluralLabel?: string | undefined;
+    }>>>;
+    /** App/Menu translations */
+    apps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        description?: string | undefined;
+    }, {
+        label: string;
+        description?: string | undefined;
+    }>>>;
+    /** UI Messages */
+    messages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    objects?: Record<string, {
+        label: string;
+        fields?: Record<string, {
+            options?: Record<string, string> | undefined;
+            label?: string | undefined;
+            help?: string | undefined;
+        }> | undefined;
+        pluralLabel?: string | undefined;
+    }> | undefined;
+    apps?: Record<string, {
+        label: string;
+        description?: string | undefined;
+    }> | undefined;
+    messages?: Record<string, string> | undefined;
+}, {
+    objects?: Record<string, {
+        label: string;
+        fields?: Record<string, {
+            options?: Record<string, string> | undefined;
+            label?: string | undefined;
+            help?: string | undefined;
+        }> | undefined;
+        pluralLabel?: string | undefined;
+    }> | undefined;
+    apps?: Record<string, {
+        label: string;
+        description?: string | undefined;
+    }> | undefined;
+    messages?: Record<string, string> | undefined;
+}>>;
+export type TranslationBundle = z.infer<typeof TranslationBundleSchema>;
+//# sourceMappingURL=translation.zod.d.ts.map

package/dist/system/translation.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translation.zod.d.ts","sourceRoot":"","sources":["../../src/system/translation.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;IAChC,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAW1B,4BAA4B;;;;;;;;;;;IAM5B,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAElB,CAAC;AAEH,eAAO,MAAM,YAAY,aAAiE,CAAC;AAE3F,eAAO,MAAM,uBAAuB;IAvBlC,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAW1B,4BAA4B;;;;;;;;;;;IAM5B,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAMgE,CAAC;AAErF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}