@zaflun/lumio-extension-types 0.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zaflun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# @zaflun/lumio-extension-types
+
+Shared TypeScript types for the [Lumio](https://lumio.vision) Extension Platform. Used by `@zaflun/lumio-sdk` and `@zaflun/lumio-cli` for type-safe extension development.
+
+## Installation
+
+```bash
+npm install @zaflun/lumio-extension-types
+```
+
+## What's included
+
+### Extension Types
+
+```typescript
+import type { Extension, ExtensionVersion, ExtensionInstall } from "@zaflun/lumio-extension-types";
+import { extensionSchema, extensionCategorySchema } from "@zaflun/lumio-extension-types";
+```
+
+- `Extension` — Store listing (name, slug, category, pricing, ratings)
+- `ExtensionVersion` — Version metadata (status, manifest, bundle hash)
+- `ExtensionInstall` — Per-account installation (config, auto-update)
+- `ExtensionReview` — User review (rating 1-5, comment)
+
+### Config Types
+
+```typescript
+import type { LumioExtensionConfig } from "@zaflun/lumio-extension-types";
+import { lumioExtensionConfigSchema } from "@zaflun/lumio-extension-types";
+
+// Validate a lumio.config.json file
+const result = lumioExtensionConfigSchema.safeParse(configData);
+```
+
+### Developer Types
+
+```typescript
+import type { DeveloperProfile, DeveloperTeam } from "@zaflun/lumio-extension-types";
+```
+
+### Enums
+
+```typescript
+import {
+  EXTENSION_CATEGORIES,    // widget, extension, overlay, bot_module, integration, theme
+  EXTENSION_VISIBILITIES,  // private, unlisted, public, paid
+  EXTENSION_STATUSES,      // draft, published, deprecated, ...
+  VERSION_STATUSES,        // draft, pending_review, testing, published, ...
+  DEVELOPER_TYPES,         // individual, company
+  DEVELOPER_TEAM_ROLES,    // owner, admin, member
+} from "@zaflun/lumio-extension-types";
+```
+
+All types include Zod schemas for runtime validation.
+
+## Documentation
+
+- [Type Reference](https://developers.lumio.vision/api-reference/types)
+- [Full Docs](https://developers.lumio.vision)
+
+## License
+
+MIT © [zaflun](https://withzaflun.com)

package/dist/index.d.ts

@@ -0,0 +1,302 @@
+import { z } from 'zod/v4';
+
+declare const EXTENSION_CATEGORIES: readonly ["widget", "extension", "overlay", "bot_module", "integration", "theme"];
+declare const EXTENSION_VISIBILITIES: readonly ["private", "unlisted", "public", "paid"];
+declare const EXTENSION_STATUSES: readonly ["draft", "published", "deprecated", "pending_deletion", "deleted", "suspended"];
+declare const VERSION_STATUSES: readonly ["draft", "pending_review", "testing", "pending_publish", "published", "rejected", "deprecated", "suspended"];
+declare const extensionCategorySchema: z.ZodEnum<{
+    widget: "widget";
+    extension: "extension";
+    overlay: "overlay";
+    bot_module: "bot_module";
+    integration: "integration";
+    theme: "theme";
+}>;
+declare const extensionVisibilitySchema: z.ZodEnum<{
+    private: "private";
+    unlisted: "unlisted";
+    public: "public";
+    paid: "paid";
+}>;
+declare const extensionStatusSchema: z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+    deprecated: "deprecated";
+    pending_deletion: "pending_deletion";
+    deleted: "deleted";
+    suspended: "suspended";
+}>;
+declare const versionStatusSchema: z.ZodEnum<{
+    draft: "draft";
+    published: "published";
+    deprecated: "deprecated";
+    suspended: "suspended";
+    pending_review: "pending_review";
+    testing: "testing";
+    pending_publish: "pending_publish";
+    rejected: "rejected";
+}>;
+type ExtensionCategory = z.infer<typeof extensionCategorySchema>;
+type ExtensionVisibility = z.infer<typeof extensionVisibilitySchema>;
+type ExtensionStatus = z.infer<typeof extensionStatusSchema>;
+type VersionStatus = z.infer<typeof versionStatusSchema>;
+declare const extensionSchema: z.ZodObject<{
+    id: z.ZodString;
+    short_id: z.ZodString;
+    developer_id: z.ZodNullable<z.ZodString>;
+    team_id: z.ZodNullable<z.ZodString>;
+    slug: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    category: z.ZodEnum<{
+        widget: "widget";
+        extension: "extension";
+        overlay: "overlay";
+        bot_module: "bot_module";
+        integration: "integration";
+        theme: "theme";
+    }>;
+    visibility: z.ZodEnum<{
+        private: "private";
+        unlisted: "unlisted";
+        public: "public";
+        paid: "paid";
+    }>;
+    icon_key: z.ZodNullable<z.ZodString>;
+    pricing_type: z.ZodEnum<{
+        free: "free";
+        one_time: "one_time";
+        subscription: "subscription";
+    }>;
+    pricing_amount: z.ZodNullable<z.ZodNumber>;
+    pricing_currency: z.ZodString;
+    pricing_interval: z.ZodNullable<z.ZodString>;
+    install_count: z.ZodNumber;
+    rating_avg: z.ZodNumber;
+    rating_count: z.ZodNumber;
+    status: z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+        deprecated: "deprecated";
+        pending_deletion: "pending_deletion";
+        deleted: "deleted";
+        suspended: "suspended";
+    }>;
+    published_at: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+type Extension = z.infer<typeof extensionSchema>;
+declare const extensionVersionSchema: z.ZodObject<{
+    id: z.ZodString;
+    extension_id: z.ZodString;
+    version: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        published: "published";
+        deprecated: "deprecated";
+        suspended: "suspended";
+        pending_review: "pending_review";
+        testing: "testing";
+        pending_publish: "pending_publish";
+        rejected: "rejected";
+    }>;
+    bundle_key: z.ZodNullable<z.ZodString>;
+    source_key: z.ZodNullable<z.ZodString>;
+    bundle_hash: z.ZodNullable<z.ZodString>;
+    manifest: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    is_breaking: z.ZodBoolean;
+    release_notes: z.ZodNullable<z.ZodString>;
+    changelog_entry: z.ZodNullable<z.ZodString>;
+    review_notes: z.ZodNullable<z.ZodString>;
+    reviewed_by: z.ZodNullable<z.ZodString>;
+    reviewed_at: z.ZodNullable<z.ZodString>;
+    published_at: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+}, z.core.$strip>;
+type ExtensionVersion = z.infer<typeof extensionVersionSchema>;
+declare const extensionInstallSchema: z.ZodObject<{
+    id: z.ZodString;
+    extension_id: z.ZodString;
+    account_id: z.ZodString;
+    version_id: z.ZodString;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    auto_update: z.ZodBoolean;
+    pinned_version_id: z.ZodNullable<z.ZodString>;
+    data_deletion_at: z.ZodNullable<z.ZodString>;
+    installed_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+type ExtensionInstall = z.infer<typeof extensionInstallSchema>;
+declare const extensionReviewSchema: z.ZodObject<{
+    id: z.ZodString;
+    extension_id: z.ZodString;
+    user_id: z.ZodString;
+    rating: z.ZodNumber;
+    comment: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+type ExtensionReview = z.infer<typeof extensionReviewSchema>;
+
+declare const PRICING_TYPES: readonly ["free", "one_time", "subscription"];
+declare const CONFIG_FIELD_TYPES: readonly ["string", "number", "boolean", "color", "select"];
+declare const pricingTypeSchema: z.ZodEnum<{
+    free: "free";
+    one_time: "one_time";
+    subscription: "subscription";
+}>;
+type PricingType = z.infer<typeof pricingTypeSchema>;
+declare const extensionPricingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"free">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"one_time">;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"subscription">;
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    interval: z.ZodString;
+}, z.core.$strip>], "type">;
+type ExtensionPricing = z.infer<typeof extensionPricingSchema>;
+declare const configFieldSchema: z.ZodObject<{
+    key: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        color: "color";
+        select: "select";
+    }>;
+    label: z.ZodString;
+    default_value: z.ZodUnknown;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type ConfigField = z.infer<typeof configFieldSchema>;
+declare const configSchemaSchema: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        color: "color";
+        select: "select";
+    }>;
+    label: z.ZodString;
+    default_value: z.ZodUnknown;
+    required: z.ZodBoolean;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>;
+type ConfigSchema = z.infer<typeof configSchemaSchema>;
+declare const lumioExtensionConfigSchema: z.ZodObject<{
+    extension_id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodEnum<{
+        widget: "widget";
+        extension: "extension";
+        overlay: "overlay";
+        bot_module: "bot_module";
+        integration: "integration";
+        theme: "theme";
+    }>;
+    version: z.ZodString;
+    targets: z.ZodArray<z.ZodEnum<{
+        editor: "editor";
+        layer: "layer";
+        interactive: "interactive";
+    }>>;
+    server: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    permissions: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    egress: z.ZodOptional<z.ZodObject<{
+        allow_hosts: z.ZodArray<z.ZodString>;
+        allow_ports: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    fonts: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    visibility: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        private: "private";
+        unlisted: "unlisted";
+        public: "public";
+        paid: "paid";
+    }>>>;
+    pricing: z.ZodDefault<z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"free">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"one_time">;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"subscription">;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+        interval: z.ZodString;
+    }, z.core.$strip>], "type">>>;
+    config_schema: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            color: "color";
+            select: "select";
+        }>;
+        label: z.ZodString;
+        default_value: z.ZodUnknown;
+        required: z.ZodBoolean;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type LumioExtensionConfig = z.infer<typeof lumioExtensionConfigSchema>;
+
+declare const DEVELOPER_TYPES: readonly ["individual", "company"];
+declare const developerTypeSchema: z.ZodEnum<{
+    individual: "individual";
+    company: "company";
+}>;
+type DeveloperType = z.infer<typeof developerTypeSchema>;
+declare const DEVELOPER_VERIFICATION_STATUSES: readonly ["pending", "verified", "rejected"];
+declare const developerVerificationStatusSchema: z.ZodEnum<{
+    rejected: "rejected";
+    pending: "pending";
+    verified: "verified";
+}>;
+type DeveloperVerificationStatus = z.infer<typeof developerVerificationStatusSchema>;
+declare const developerProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    user_id: z.ZodString;
+    stripe_connect_id: z.ZodNullable<z.ZodString>;
+    paypal_email: z.ZodNullable<z.ZodString>;
+    bank_iban: z.ZodNullable<z.ZodString>;
+    bank_bic: z.ZodNullable<z.ZodString>;
+    bank_name: z.ZodNullable<z.ZodString>;
+    payout_method: z.ZodNullable<z.ZodEnum<{
+        stripe: "stripe";
+        paypal: "paypal";
+        bank: "bank";
+    }>>;
+    revenue_balance: z.ZodNumber;
+    total_earned: z.ZodNumber;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+type DeveloperProfile = z.infer<typeof developerProfileSchema>;
+declare const developerTeamSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    owner_id: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+type DeveloperTeam = z.infer<typeof developerTeamSchema>;
+declare const DEVELOPER_TEAM_ROLES: readonly ["owner", "admin", "member"];
+declare const developerTeamRoleSchema: z.ZodEnum<{
+    owner: "owner";
+    admin: "admin";
+    member: "member";
+}>;
+type DeveloperTeamRole = z.infer<typeof developerTeamRoleSchema>;
+
+export { CONFIG_FIELD_TYPES, type ConfigField, type ConfigSchema, DEVELOPER_TEAM_ROLES, DEVELOPER_TYPES, DEVELOPER_VERIFICATION_STATUSES, type DeveloperProfile, type DeveloperTeam, type DeveloperTeamRole, type DeveloperType, type DeveloperVerificationStatus, EXTENSION_CATEGORIES, EXTENSION_STATUSES, EXTENSION_VISIBILITIES, type Extension, type ExtensionCategory, type ExtensionInstall, type ExtensionPricing, type ExtensionReview, type ExtensionStatus, type ExtensionVersion, type ExtensionVisibility, type LumioExtensionConfig, PRICING_TYPES, type PricingType, VERSION_STATUSES, type VersionStatus, configFieldSchema, configSchemaSchema, developerProfileSchema, developerTeamRoleSchema, developerTeamSchema, developerTypeSchema, developerVerificationStatusSchema, extensionCategorySchema, extensionInstallSchema, extensionPricingSchema, extensionReviewSchema, extensionSchema, extensionStatusSchema, extensionVersionSchema, extensionVisibilitySchema, lumioExtensionConfigSchema, pricingTypeSchema, versionStatusSchema };

package/dist/index.js

@@ -0,0 +1,221 @@
+// src/extension.ts
+import { z } from "zod/v4";
+var EXTENSION_CATEGORIES = [
+  "widget",
+  "extension",
+  "overlay",
+  "bot_module",
+  "integration",
+  "theme"
+];
+var EXTENSION_VISIBILITIES = [
+  "private",
+  "unlisted",
+  "public",
+  "paid"
+];
+var EXTENSION_STATUSES = [
+  "draft",
+  "published",
+  "deprecated",
+  "pending_deletion",
+  "deleted",
+  "suspended"
+];
+var VERSION_STATUSES = [
+  "draft",
+  "pending_review",
+  "testing",
+  "pending_publish",
+  "published",
+  "rejected",
+  "deprecated",
+  "suspended"
+];
+var extensionCategorySchema = z.enum(EXTENSION_CATEGORIES);
+var extensionVisibilitySchema = z.enum(EXTENSION_VISIBILITIES);
+var extensionStatusSchema = z.enum(EXTENSION_STATUSES);
+var versionStatusSchema = z.enum(VERSION_STATUSES);
+var extensionSchema = z.object({
+  id: z.string(),
+  short_id: z.string(),
+  developer_id: z.string().nullable(),
+  team_id: z.string().nullable(),
+  slug: z.string(),
+  name: z.string(),
+  description: z.string().nullable(),
+  category: extensionCategorySchema,
+  visibility: extensionVisibilitySchema,
+  icon_key: z.string().nullable(),
+  pricing_type: z.enum(["free", "one_time", "subscription"]),
+  pricing_amount: z.number().nullable(),
+  pricing_currency: z.string(),
+  pricing_interval: z.string().nullable(),
+  install_count: z.number(),
+  rating_avg: z.number(),
+  rating_count: z.number(),
+  status: extensionStatusSchema,
+  published_at: z.string().nullable(),
+  created_at: z.string(),
+  updated_at: z.string()
+});
+var extensionVersionSchema = z.object({
+  id: z.string(),
+  extension_id: z.string(),
+  version: z.string(),
+  status: versionStatusSchema,
+  bundle_key: z.string().nullable(),
+  source_key: z.string().nullable(),
+  bundle_hash: z.string().nullable(),
+  manifest: z.record(z.string(), z.unknown()),
+  is_breaking: z.boolean(),
+  release_notes: z.string().nullable(),
+  changelog_entry: z.string().nullable(),
+  review_notes: z.string().nullable(),
+  reviewed_by: z.string().nullable(),
+  reviewed_at: z.string().nullable(),
+  published_at: z.string().nullable(),
+  created_at: z.string()
+});
+var extensionInstallSchema = z.object({
+  id: z.string(),
+  extension_id: z.string(),
+  account_id: z.string(),
+  version_id: z.string(),
+  config: z.record(z.string(), z.unknown()),
+  auto_update: z.boolean(),
+  pinned_version_id: z.string().nullable(),
+  data_deletion_at: z.string().nullable(),
+  installed_at: z.string(),
+  updated_at: z.string()
+});
+var extensionReviewSchema = z.object({
+  id: z.string(),
+  extension_id: z.string(),
+  user_id: z.string(),
+  rating: z.number().int().min(1).max(5),
+  comment: z.string().nullable(),
+  created_at: z.string(),
+  updated_at: z.string()
+});
+
+// src/config.ts
+import { z as z2 } from "zod/v4";
+var PRICING_TYPES = ["free", "one_time", "subscription"];
+var CONFIG_FIELD_TYPES = [
+  "string",
+  "number",
+  "boolean",
+  "color",
+  "select"
+];
+var pricingTypeSchema = z2.enum(PRICING_TYPES);
+var extensionPricingSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("free")
+  }),
+  z2.object({
+    type: z2.literal("one_time"),
+    amount: z2.number(),
+    currency: z2.string()
+  }),
+  z2.object({
+    type: z2.literal("subscription"),
+    amount: z2.number(),
+    currency: z2.string(),
+    interval: z2.string()
+  })
+]);
+var configFieldSchema = z2.object({
+  key: z2.string(),
+  type: z2.enum(CONFIG_FIELD_TYPES),
+  label: z2.string(),
+  default_value: z2.unknown(),
+  required: z2.boolean(),
+  options: z2.array(z2.string()).optional()
+});
+var configSchemaSchema = z2.array(configFieldSchema);
+var lumioExtensionConfigSchema = z2.object({
+  extension_id: z2.string(),
+  name: z2.string(),
+  description: z2.string().optional(),
+  category: extensionCategorySchema,
+  version: z2.string(),
+  targets: z2.array(z2.enum(["editor", "layer", "interactive"])).min(1),
+  server: z2.boolean().optional().default(false),
+  permissions: z2.array(z2.string()).optional().default([]),
+  egress: z2.object({
+    allow_hosts: z2.array(z2.string()),
+    allow_ports: z2.array(z2.number())
+  }).optional(),
+  fonts: z2.array(z2.string()).optional().default([]),
+  visibility: extensionVisibilitySchema.optional().default("private"),
+  pricing: extensionPricingSchema.optional().default({ type: "free" }),
+  config_schema: configSchemaSchema.optional()
+});
+
+// src/developer.ts
+import { z as z3 } from "zod/v4";
+var DEVELOPER_TYPES = ["individual", "company"];
+var developerTypeSchema = z3.enum(DEVELOPER_TYPES);
+var DEVELOPER_VERIFICATION_STATUSES = [
+  "pending",
+  "verified",
+  "rejected"
+];
+var developerVerificationStatusSchema = z3.enum(
+  DEVELOPER_VERIFICATION_STATUSES
+);
+var developerProfileSchema = z3.object({
+  id: z3.string(),
+  user_id: z3.string(),
+  stripe_connect_id: z3.string().nullable(),
+  paypal_email: z3.string().nullable(),
+  bank_iban: z3.string().nullable(),
+  bank_bic: z3.string().nullable(),
+  bank_name: z3.string().nullable(),
+  payout_method: z3.enum(["stripe", "paypal", "bank"]).nullable(),
+  revenue_balance: z3.number(),
+  total_earned: z3.number(),
+  created_at: z3.string(),
+  updated_at: z3.string()
+});
+var developerTeamSchema = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  slug: z3.string(),
+  owner_id: z3.string(),
+  created_at: z3.string(),
+  updated_at: z3.string()
+});
+var DEVELOPER_TEAM_ROLES = ["owner", "admin", "member"];
+var developerTeamRoleSchema = z3.enum(DEVELOPER_TEAM_ROLES);
+export {
+  CONFIG_FIELD_TYPES,
+  DEVELOPER_TEAM_ROLES,
+  DEVELOPER_TYPES,
+  DEVELOPER_VERIFICATION_STATUSES,
+  EXTENSION_CATEGORIES,
+  EXTENSION_STATUSES,
+  EXTENSION_VISIBILITIES,
+  PRICING_TYPES,
+  VERSION_STATUSES,
+  configFieldSchema,
+  configSchemaSchema,
+  developerProfileSchema,
+  developerTeamRoleSchema,
+  developerTeamSchema,
+  developerTypeSchema,
+  developerVerificationStatusSchema,
+  extensionCategorySchema,
+  extensionInstallSchema,
+  extensionPricingSchema,
+  extensionReviewSchema,
+  extensionSchema,
+  extensionStatusSchema,
+  extensionVersionSchema,
+  extensionVisibilitySchema,
+  lumioExtensionConfigSchema,
+  pricingTypeSchema,
+  versionStatusSchema
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@zaflun/lumio-extension-types",
+  "version": "0.1.0",
+  "description": "Shared TypeScript types for Lumio extensions, store, and config",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.2",
+    "tsup": "^8.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": {
+    "name": "zaflun",
+    "email": "developers@zaflun.com",
+    "url": "https://withzaflun.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zaflun/lumio.git",
+    "directory": "packages/extension-types"
+  },
+  "homepage": "https://developers.lumio.vision",
+  "bugs": {
+    "url": "https://github.com/zaflun/lumio/issues",
+    "email": "developers@zaflun.com"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "test": "vitest run"
+  }
+}