@objectstack/spec 0.1.0 → 0.1.1

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

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+/**
+ * Authentication Protocol
+ * Defines supported authentication standards (OIDC, SAML, LDAP).
+ */
+export declare const AuthProtocol: z.ZodEnum<["oidc", "saml", "ldap", "oauth2", "local", "mock"]>;
+/**
+ * OIDC / OAuth2 Config (Standard)
+ */
+export declare const OIDCConfigSchema: z.ZodObject<{
+    issuer: z.ZodString;
+    clientId: z.ZodString;
+    clientSecret: z.ZodString;
+    scopes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    attributeMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    issuer: string;
+    clientId: string;
+    clientSecret: string;
+    scopes: string[];
+    attributeMapping?: Record<string, string> | undefined;
+}, {
+    issuer: string;
+    clientId: string;
+    clientSecret: string;
+    scopes?: string[] | undefined;
+    attributeMapping?: Record<string, string> | undefined;
+}>;
+/**
+ * SAML 2.0 Config (Enterprise)
+ */
+export declare const SAMLConfigSchema: z.ZodObject<{
+    entryPoint: z.ZodString;
+    cert: z.ZodString;
+    issuer: z.ZodString;
+    signatureAlgorithm: z.ZodDefault<z.ZodEnum<["sha256", "sha512"]>>;
+    attributeMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    issuer: string;
+    entryPoint: string;
+    cert: string;
+    signatureAlgorithm: "sha256" | "sha512";
+    attributeMapping?: Record<string, string> | undefined;
+}, {
+    issuer: string;
+    entryPoint: string;
+    cert: string;
+    attributeMapping?: Record<string, string> | undefined;
+    signatureAlgorithm?: "sha256" | "sha512" | undefined;
+}>;
+/**
+ * LDAP / AD Config (On-premise)
+ */
+export declare const LDAPConfigSchema: z.ZodObject<{
+    url: z.ZodString;
+    bindDn: z.ZodString;
+    bindCredentials: z.ZodString;
+    searchBase: z.ZodString;
+    searchFilter: z.ZodString;
+    groupSearchBase: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    bindDn: string;
+    bindCredentials: string;
+    searchBase: string;
+    searchFilter: string;
+    groupSearchBase?: string | undefined;
+}, {
+    url: string;
+    bindDn: string;
+    bindCredentials: string;
+    searchBase: string;
+    searchFilter: string;
+    groupSearchBase?: string | undefined;
+}>;
+/**
+ * Identity Provider (IdP) Schema
+ * Connects the OS to an external source of truth for identities.
+ */
+export declare const AuthProviderSchema: z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodString;
+    type: z.ZodEnum<["oidc", "saml", "ldap", "oauth2", "local", "mock"]>;
+    /** Configuration (Polymorphic based on type) */
+    config: z.ZodUnion<[z.ZodObject<{
+        issuer: z.ZodString;
+        clientId: z.ZodString;
+        clientSecret: z.ZodString;
+        scopes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        attributeMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        issuer: string;
+        clientId: string;
+        clientSecret: string;
+        scopes: string[];
+        attributeMapping?: Record<string, string> | undefined;
+    }, {
+        issuer: string;
+        clientId: string;
+        clientSecret: string;
+        scopes?: string[] | undefined;
+        attributeMapping?: Record<string, string> | undefined;
+    }>, z.ZodObject<{
+        entryPoint: z.ZodString;
+        cert: z.ZodString;
+        issuer: z.ZodString;
+        signatureAlgorithm: z.ZodDefault<z.ZodEnum<["sha256", "sha512"]>>;
+        attributeMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        issuer: string;
+        entryPoint: string;
+        cert: string;
+        signatureAlgorithm: "sha256" | "sha512";
+        attributeMapping?: Record<string, string> | undefined;
+    }, {
+        issuer: string;
+        entryPoint: string;
+        cert: string;
+        attributeMapping?: Record<string, string> | undefined;
+        signatureAlgorithm?: "sha256" | "sha512" | undefined;
+    }>, z.ZodObject<{
+        url: z.ZodString;
+        bindDn: z.ZodString;
+        bindCredentials: z.ZodString;
+        searchBase: z.ZodString;
+        searchFilter: z.ZodString;
+        groupSearchBase: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        bindDn: string;
+        bindCredentials: string;
+        searchBase: string;
+        searchFilter: string;
+        groupSearchBase?: string | undefined;
+    }, {
+        url: string;
+        bindDn: string;
+        bindCredentials: string;
+        searchBase: string;
+        searchFilter: string;
+        groupSearchBase?: string | undefined;
+    }>, z.ZodRecord<z.ZodString, z.ZodAny>]>;
+    /** Visuals */
+    icon: z.ZodOptional<z.ZodString>;
+    /** Policies */
+    active: z.ZodDefault<z.ZodBoolean>;
+    registrationEnabled: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "local" | "oidc" | "saml" | "ldap" | "oauth2" | "mock";
+    label: string;
+    name: string;
+    active: boolean;
+    config: Record<string, any> | {
+        issuer: string;
+        clientId: string;
+        clientSecret: string;
+        scopes: string[];
+        attributeMapping?: Record<string, string> | undefined;
+    } | {
+        issuer: string;
+        entryPoint: string;
+        cert: string;
+        signatureAlgorithm: "sha256" | "sha512";
+        attributeMapping?: Record<string, string> | undefined;
+    } | {
+        url: string;
+        bindDn: string;
+        bindCredentials: string;
+        searchBase: string;
+        searchFilter: string;
+        groupSearchBase?: string | undefined;
+    };
+    registrationEnabled: boolean;
+    icon?: string | undefined;
+}, {
+    type: "local" | "oidc" | "saml" | "ldap" | "oauth2" | "mock";
+    label: string;
+    name: string;
+    config: Record<string, any> | {
+        issuer: string;
+        clientId: string;
+        clientSecret: string;
+        scopes?: string[] | undefined;
+        attributeMapping?: Record<string, string> | undefined;
+    } | {
+        issuer: string;
+        entryPoint: string;
+        cert: string;
+        attributeMapping?: Record<string, string> | undefined;
+        signatureAlgorithm?: "sha256" | "sha512" | undefined;
+    } | {
+        url: string;
+        bindDn: string;
+        bindCredentials: string;
+        searchBase: string;
+        searchFilter: string;
+        groupSearchBase?: string | undefined;
+    };
+    icon?: string | undefined;
+    active?: boolean | undefined;
+    registrationEnabled?: boolean | undefined;
+}>;
+export type AuthProvider = z.infer<typeof AuthProviderSchema>;
+//# sourceMappingURL=identity.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"identity.zod.d.ts","sourceRoot":"","sources":["../../src/system/identity.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,YAAY,gEAOvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;EAM3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;EAM3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;EAO3B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;IAK7B,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQhD,cAAc;;IAGd,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGf,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/system/identity.zod.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthProviderSchema = exports.LDAPConfigSchema = exports.SAMLConfigSchema = exports.OIDCConfigSchema = exports.AuthProtocol = void 0;
+const zod_1 = require("zod");
+/**
+ * Authentication Protocol
+ * Defines supported authentication standards (OIDC, SAML, LDAP).
+ */
+exports.AuthProtocol = zod_1.z.enum([
+    'oidc', // OpenID Connect (Modern standard)
+    'saml', // SAML 2.0 (Legacy Enterprise)
+    'ldap', // LDAP/Active Directory (On-premise)
+    'oauth2', // Generic OAuth2
+    'local', // Database username/password
+    'mock' // Testing
+]);
+/**
+ * OIDC / OAuth2 Config (Standard)
+ */
+exports.OIDCConfigSchema = zod_1.z.object({
+    issuer: zod_1.z.string().url().describe('OIDC Issuer URL (.well-known/openid-configuration)'),
+    clientId: zod_1.z.string(),
+    clientSecret: zod_1.z.string(), // Usually value is ENV reference
+    scopes: zod_1.z.array(zod_1.z.string()).default(['openid', 'profile', 'email']),
+    attributeMapping: zod_1.z.record(zod_1.z.string()).optional().describe('Map IdP claims to User fields'),
+});
+/**
+ * SAML 2.0 Config (Enterprise)
+ */
+exports.SAMLConfigSchema = zod_1.z.object({
+    entryPoint: zod_1.z.string().url().describe('IdP SSO URL'),
+    cert: zod_1.z.string().describe('IdP Public Certificate'), // PEM format
+    issuer: zod_1.z.string().describe('Entity ID of the IdP'),
+    signatureAlgorithm: zod_1.z.enum(['sha256', 'sha512']).default('sha256'),
+    attributeMapping: zod_1.z.record(zod_1.z.string()).optional(),
+});
+/**
+ * LDAP / AD Config (On-premise)
+ */
+exports.LDAPConfigSchema = zod_1.z.object({
+    url: zod_1.z.string().url().describe('LDAP Server URL (ldap:// or ldaps://)'),
+    bindDn: zod_1.z.string(),
+    bindCredentials: zod_1.z.string(),
+    searchBase: zod_1.z.string(),
+    searchFilter: zod_1.z.string(),
+    groupSearchBase: zod_1.z.string().optional(),
+});
+/**
+ * Identity Provider (IdP) Schema
+ * Connects the OS to an external source of truth for identities.
+ */
+exports.AuthProviderSchema = zod_1.z.object({
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Provider ID'),
+    label: zod_1.z.string().describe('Button Label (e.g. "Login with Okta")'),
+    type: exports.AuthProtocol,
+    /** Configuration (Polymorphic based on type) */
+    config: zod_1.z.union([
+        exports.OIDCConfigSchema,
+        exports.SAMLConfigSchema,
+        exports.LDAPConfigSchema,
+        zod_1.z.record(zod_1.z.any()) // Fallback
+    ]).describe('Provider specific configuration'),
+    /** Visuals */
+    icon: zod_1.z.string().optional().describe('Icon URL or helper class'),
+    /** Policies */
+    active: zod_1.z.boolean().default(true),
+    registrationEnabled: zod_1.z.boolean().default(false).describe('Allow new users to sign up via this provider'),
+});

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

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+/**
+ * Metric Type Classification
+ */
+export declare const MetricType: z.ZodEnum<["boolean", "counter", "gauge"]>;
+/**
+ * Feature/Limit Definition Schema
+ * Defines a controllable capability of the system.
+ */
+export declare const FeatureSchema: z.ZodObject<{
+    code: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodDefault<z.ZodEnum<["boolean", "counter", "gauge"]>>;
+    /** For counters/gauges */
+    unit: z.ZodOptional<z.ZodEnum<["count", "bytes", "seconds", "percent"]>>;
+    /** Dependencies (e.g. 'audit_log' requires 'enterprise_tier') */
+    requires: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    type: "boolean" | "counter" | "gauge";
+    label: string;
+    description?: string | undefined;
+    unit?: "percent" | "count" | "bytes" | "seconds" | undefined;
+    requires?: string[] | undefined;
+}, {
+    code: string;
+    label: string;
+    type?: "boolean" | "counter" | "gauge" | undefined;
+    description?: string | undefined;
+    unit?: "percent" | "count" | "bytes" | "seconds" | undefined;
+    requires?: string[] | undefined;
+}>;
+/**
+ * Subscription Plan Schema
+ * Defines a tier of service (e.g. "Free", "Pro", "Enterprise").
+ */
+export declare const PlanSchema: z.ZodObject<{
+    code: z.ZodString;
+    label: z.ZodString;
+    active: z.ZodDefault<z.ZodBoolean>;
+    /** Feature Entitlements */
+    features: z.ZodArray<z.ZodString, "many">;
+    /** Limit Quotas */
+    limits: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    /** Pricing (Optional Metadata) */
+    currency: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    priceMonthly: z.ZodOptional<z.ZodNumber>;
+    priceYearly: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    label: string;
+    active: boolean;
+    features: string[];
+    limits: Record<string, number>;
+    currency?: string | undefined;
+    priceMonthly?: number | undefined;
+    priceYearly?: number | undefined;
+}, {
+    code: string;
+    label: string;
+    features: string[];
+    limits: Record<string, number>;
+    currency?: string | undefined;
+    active?: boolean | undefined;
+    priceMonthly?: number | undefined;
+    priceYearly?: number | undefined;
+}>;
+/**
+ * License Schema
+ * The actual entitlement object assigned to a Tenant.
+ * Often signed as a JWT.
+ */
+export declare const LicenseSchema: z.ZodObject<{
+    /** Identity */
+    tenantId: z.ZodString;
+    planCode: z.ZodString;
+    /** Validity */
+    issuedAt: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    /** Status */
+    status: z.ZodEnum<["active", "expired", "suspended", "trial"]>;
+    /** Overrides (Specific to this tenant, exceeding the plan) */
+    customFeatures: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    customLimits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    /** Signature */
+    signature: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "active" | "expired" | "suspended" | "trial";
+    tenantId: string;
+    planCode: string;
+    issuedAt: string;
+    expiresAt?: string | undefined;
+    customFeatures?: string[] | undefined;
+    customLimits?: Record<string, number> | undefined;
+    signature?: string | undefined;
+}, {
+    status: "active" | "expired" | "suspended" | "trial";
+    tenantId: string;
+    planCode: string;
+    issuedAt: string;
+    expiresAt?: string | undefined;
+    customFeatures?: string[] | undefined;
+    customLimits?: Record<string, number> | undefined;
+    signature?: string | undefined;
+}>;
+export type Feature = z.infer<typeof FeatureSchema>;
+export type Plan = z.infer<typeof PlanSchema>;
+export type License = z.infer<typeof LicenseSchema>;
+//# sourceMappingURL=license.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"license.zod.d.ts","sourceRoot":"","sources":["../../src/system/license.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,UAAU,4CAIrB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;IAOxB,0BAA0B;;IAG1B,iEAAiE;;;;;;;;;;;;;;;;EAEjE,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;IAKrB,2BAA2B;;IAG3B,mBAAmB;;IAGnB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;EAIlC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,aAAa;IACxB,eAAe;;;IAIf,eAAe;;;IAIf,aAAa;;IAGb,8DAA8D;;;IAI9D,gBAAgB;;;;;;;;;;;;;;;;;;;;EAEhB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/system/license.zod.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicenseSchema = exports.PlanSchema = exports.FeatureSchema = exports.MetricType = void 0;
+const zod_1 = require("zod");
+/**
+ * Metric Type Classification
+ */
+exports.MetricType = zod_1.z.enum([
+    'boolean', // Feature Flag (Enabled/Disabled)
+    'counter', // Usage Count (e.g. API Calls, Records Created) - Accumulates
+    'gauge', // Current Level (e.g. Storage Used, Users Active) - Point in time
+]);
+/**
+ * Feature/Limit Definition Schema
+ * Defines a controllable capability of the system.
+ */
+exports.FeatureSchema = zod_1.z.object({
+    code: zod_1.z.string().regex(/^[a-z_][a-z0-9_.]*$/).describe('Feature code (e.g. core.api_access)'),
+    label: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    type: exports.MetricType.default('boolean'),
+    /** For counters/gauges */
+    unit: zod_1.z.enum(['count', 'bytes', 'seconds', 'percent']).optional(),
+    /** Dependencies (e.g. 'audit_log' requires 'enterprise_tier') */
+    requires: zod_1.z.array(zod_1.z.string()).optional(),
+});
+/**
+ * Subscription Plan Schema
+ * Defines a tier of service (e.g. "Free", "Pro", "Enterprise").
+ */
+exports.PlanSchema = zod_1.z.object({
+    code: zod_1.z.string().describe('Plan code (e.g. pro_v1)'),
+    label: zod_1.z.string(),
+    active: zod_1.z.boolean().default(true),
+    /** Feature Entitlements */
+    features: zod_1.z.array(zod_1.z.string()).describe('List of enabled boolean features'),
+    /** Limit Quotas */
+    limits: zod_1.z.record(zod_1.z.number()).describe('Map of metric codes to limit values (e.g. { storage_gb: 10 })'),
+    /** Pricing (Optional Metadata) */
+    currency: zod_1.z.string().default('USD').optional(),
+    priceMonthly: zod_1.z.number().optional(),
+    priceYearly: zod_1.z.number().optional(),
+});
+/**
+ * License Schema
+ * The actual entitlement object assigned to a Tenant.
+ * Often signed as a JWT.
+ */
+exports.LicenseSchema = zod_1.z.object({
+    /** Identity */
+    tenantId: zod_1.z.string(),
+    planCode: zod_1.z.string(),
+    /** Validity */
+    issuedAt: zod_1.z.string().datetime(),
+    expiresAt: zod_1.z.string().datetime().optional(), // Null = Perpetual
+    /** Status */
+    status: zod_1.z.enum(['active', 'expired', 'suspended', 'trial']),
+    /** Overrides (Specific to this tenant, exceeding the plan) */
+    customFeatures: zod_1.z.array(zod_1.z.string()).optional(),
+    customLimits: zod_1.z.record(zod_1.z.number()).optional(),
+    /** Signature */
+    signature: zod_1.z.string().optional().describe('Cryptographic signature of the license'),
+});

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

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+/**
+ * Schema for menu items in ObjectStack packages.
+ * Defines navigation structure that can be injected into the UI.
+ */
+export declare const MenuItemSchema: z.ZodObject<{
+    /** Display label for the menu item */
+    label: z.ZodString;
+    /** Navigation path (route) for the menu item */
+    path: z.ZodString;
+    /** Optional icon identifier for the menu item */
+    icon: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    label: string;
+    icon?: string | undefined;
+}, {
+    path: string;
+    label: string;
+    icon?: string | undefined;
+}>;
+/**
+ * Schema for the ObjectStack Manifest.
+ * This defines the structure of a package configuration in the ObjectStack ecosystem.
+ * All packages (apps, plugins, drivers, modules) must conform to this schema.
+ */
+export declare const ManifestSchema: z.ZodObject<{
+    /**
+     * Unique package identifier using reverse domain notation.
+     * Example: "com.example.crm"
+     */
+    id: z.ZodString;
+    /**
+     * Package version following semantic versioning (major.minor.patch).
+     * Example: "1.0.0"
+     */
+    version: z.ZodString;
+    /**
+     * Type of the package in the ObjectStack ecosystem.
+     * - app: Standalone application
+     * - plugin: Extension to ObjectOS
+     * - driver: Low-level integration driver
+     * - module: Reusable code module
+     */
+    type: z.ZodEnum<["app", "plugin", "driver", "module"]>;
+    /**
+     * Human-readable name of the package.
+     */
+    name: z.ZodString;
+    /**
+     * Brief description of the package functionality.
+     */
+    description: z.ZodOptional<z.ZodString>;
+    /**
+     * Array of permission strings that the package requires.
+     * Example: ["system.user.read", "system.data.write"]
+     */
+    permissions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Navigation menu structure that the package contributes to the UI.
+     */
+    menus: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Display label for the menu item */
+        label: z.ZodString;
+        /** Navigation path (route) for the menu item */
+        path: z.ZodString;
+        /** Optional icon identifier for the menu item */
+        icon: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        label: string;
+        icon?: string | undefined;
+    }, {
+        path: string;
+        label: string;
+        icon?: string | undefined;
+    }>, "many">>;
+    /**
+     * Glob patterns specifying ObjectQL schemas files (typically *.object.yml or *.object.ts).
+     * Example: `["./src/objects/*.object.yml"]`
+     */
+    objects: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Extension points contributed by this package.
+     * Allows packages to extend UI components, add functionality, etc.
+     */
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    type: "app" | "plugin" | "driver" | "module";
+    name: string;
+    id: string;
+    version: string;
+    description?: string | undefined;
+    objects?: string[] | undefined;
+    permissions?: string[] | undefined;
+    menus?: {
+        path: string;
+        label: string;
+        icon?: string | undefined;
+    }[] | undefined;
+    extensions?: Record<string, any> | undefined;
+}, {
+    type: "app" | "plugin" | "driver" | "module";
+    name: string;
+    id: string;
+    version: string;
+    description?: string | undefined;
+    objects?: string[] | undefined;
+    permissions?: string[] | undefined;
+    menus?: {
+        path: string;
+        label: string;
+        icon?: string | undefined;
+    }[] | undefined;
+    extensions?: Record<string, any> | undefined;
+}>;
+/**
+ * TypeScript type inferred from the ManifestSchema.
+ * Use this type for type-safe manifest handling in TypeScript code.
+ */
+export type ObjectStackManifest = z.infer<typeof ManifestSchema>;
+/**
+ * TypeScript type for menu items.
+ */
+export type MenuItem = z.infer<typeof MenuItemSchema>;
+//# sourceMappingURL=manifest.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.zod.d.ts","sourceRoot":"","sources":["../../src/system/manifest.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,cAAc;IACzB,sCAAsC;;IAEtC,gDAAgD;;IAEhD,iDAAiD;;;;;;;;;;EAEjD,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,cAAc;IACzB;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;;;OAMG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;;OAGG;;IAGH;;OAEG;;QArDH,sCAAsC;;QAEtC,gDAAgD;;QAEhD,iDAAiD;;;;;;;;;;;IAoDjD;;;OAGG;;IAGH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEjE;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/system/manifest.zod.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestSchema = exports.MenuItemSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Schema for menu items in ObjectStack packages.
+ * Defines navigation structure that can be injected into the UI.
+ */
+exports.MenuItemSchema = zod_1.z.object({
+    /** Display label for the menu item */
+    label: zod_1.z.string().describe('Display label for the menu item'),
+    /** Navigation path (route) for the menu item */
+    path: zod_1.z.string().describe('Navigation path (route) for the menu item'),
+    /** Optional icon identifier for the menu item */
+    icon: zod_1.z.string().optional().describe('Optional icon identifier for the menu item'),
+});
+/**
+ * Schema for the ObjectStack Manifest.
+ * This defines the structure of a package configuration in the ObjectStack ecosystem.
+ * All packages (apps, plugins, drivers, modules) must conform to this schema.
+ */
+exports.ManifestSchema = zod_1.z.object({
+    /**
+     * Unique package identifier using reverse domain notation.
+     * Example: "com.example.crm"
+     */
+    id: zod_1.z.string().describe('Unique package identifier (reverse domain style)'),
+    /**
+     * Package version following semantic versioning (major.minor.patch).
+     * Example: "1.0.0"
+     */
+    version: zod_1.z.string().regex(/^\d+\.\d+\.\d+$/).describe('Package version (semantic versioning)'),
+    /**
+     * Type of the package in the ObjectStack ecosystem.
+     * - app: Standalone application
+     * - plugin: Extension to ObjectOS
+     * - driver: Low-level integration driver
+     * - module: Reusable code module
+     */
+    type: zod_1.z.enum(['app', 'plugin', 'driver', 'module']).describe('Type of package'),
+    /**
+     * Human-readable name of the package.
+     */
+    name: zod_1.z.string().describe('Human-readable package name'),
+    /**
+     * Brief description of the package functionality.
+     */
+    description: zod_1.z.string().optional().describe('Package description'),
+    /**
+     * Array of permission strings that the package requires.
+     * Example: ["system.user.read", "system.data.write"]
+     */
+    permissions: zod_1.z.array(zod_1.z.string()).optional().describe('Array of required permission strings'),
+    /**
+     * Navigation menu structure that the package contributes to the UI.
+     */
+    menus: zod_1.z.array(exports.MenuItemSchema).optional().describe('Navigation menu structure'),
+    /**
+     * Glob patterns specifying ObjectQL schemas files (typically *.object.yml or *.object.ts).
+     * Example: `["./src/objects/*.object.yml"]`
+     */
+    objects: zod_1.z.array(zod_1.z.string()).optional().describe('Glob patterns for ObjectQL schemas files'),
+    /**
+     * Extension points contributed by this package.
+     * Allows packages to extend UI components, add functionality, etc.
+     */
+    extensions: zod_1.z.record(zod_1.z.any()).optional().describe('Extension points and contributions'),
+});