@elevasis/ui 2.18.0 → 2.20.0

package/dist/provider/published.d.ts

@@ -2,6 +2,7 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode, ComponentType } from 'react';
 import { QueryClient } from '@tanstack/react-query';
 import { z } from 'zod';
+import { EventSourceMessage } from '@microsoft/fetch-event-source';
 
 /** Framework-agnostic theme overrides bundled with a preset (fonts, radius, component styles). */
 interface FrameworkThemeOverrides {
@@ -277,257 +278,327 @@ declare function ElevasisCoreProvider({ auth, queryClient, apiUrl, onError, noti
  */
 type TimeRange = '1h' | '24h' | '7d' | '30d';
 
-declare const SurfaceDefinitionSchema = z.object({
-  id: ModelIdSchema,
-  label: LabelSchema,
-  path: PathSchema,
-  surfaceType: SurfaceTypeSchema,
-  description: DescriptionSchema.optional(),
-  enabled: z.boolean().default(true),
-  icon: IconNameSchema.optional(),
-  featureId: ModelIdSchema.optional(),
-  featureIds: ReferenceIdsSchema,
-  entityIds: ReferenceIdsSchema,
-  resourceIds: ReferenceIdsSchema,
-  capabilityIds: ReferenceIdsSchema,
-  parentId: ModelIdSchema.optional()
-})
+declare const OrganizationModelSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    features: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        color: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        entityIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        surfaceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        resourceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        capabilityIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    branding: z.ZodObject<{
+        organizationName: z.ZodString;
+        productName: z.ZodString;
+        shortName: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        logos: z.ZodDefault<z.ZodObject<{
+            light: z.ZodOptional<z.ZodString>;
+            dark: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    navigation: z.ZodObject<{
+        defaultSurfaceId: z.ZodOptional<z.ZodString>;
+        surfaces: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            path: z.ZodString;
+            surfaceType: z.ZodEnum<{
+                list: "list";
+                settings: "settings";
+                page: "page";
+                dashboard: "dashboard";
+                graph: "graph";
+                detail: "detail";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            icon: z.ZodOptional<z.ZodString>;
+            featureId: z.ZodOptional<z.ZodString>;
+            featureIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            entityIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            resourceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            capabilityIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            parentId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        groups: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            placement: z.ZodString;
+            surfaceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    sales: z.ZodObject<{
+        entityId: z.ZodString;
+        defaultPipelineId: z.ZodString;
+        pipelines: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            entityId: z.ZodString;
+            stages: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                color: z.ZodOptional<z.ZodString>;
+                icon: z.ZodOptional<z.ZodString>;
+                id: z.ZodString;
+                order: z.ZodNumber;
+                semanticClass: z.ZodEnum<{
+                    open: "open";
+                    active: "active";
+                    closed_won: "closed_won";
+                    closed_lost: "closed_lost";
+                    nurturing: "nurturing";
+                }>;
+                surfaceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                resourceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    prospecting: z.ZodObject<{
+        listEntityId: z.ZodString;
+        companyEntityId: z.ZodString;
+        contactEntityId: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        companyStages: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            order: z.ZodNumber;
+        }, z.core.$strip>>;
+        contactStages: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            order: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    projects: z.ZodObject<{
+        projectEntityId: z.ZodString;
+        milestoneEntityId: z.ZodString;
+        taskEntityId: z.ZodString;
+        projectStatuses: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            order: z.ZodNumber;
+        }, z.core.$strip>>;
+        milestoneStatuses: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            order: z.ZodNumber;
+        }, z.core.$strip>>;
+        taskStatuses: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            color: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            order: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    identity: z.ZodDefault<z.ZodObject<{
+        mission: z.ZodDefault<z.ZodString>;
+        vision: z.ZodDefault<z.ZodString>;
+        legalName: z.ZodDefault<z.ZodString>;
+        entityType: z.ZodDefault<z.ZodString>;
+        jurisdiction: z.ZodDefault<z.ZodString>;
+        industryCategory: z.ZodDefault<z.ZodString>;
+        geographicFocus: z.ZodDefault<z.ZodString>;
+        timeZone: z.ZodDefault<z.ZodString>;
+        businessHours: z.ZodDefault<z.ZodObject<{
+            monday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+            tuesday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+            wednesday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+            thursday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+            friday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+            saturday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+            sunday: z.ZodOptional<z.ZodObject<{
+                open: z.ZodString;
+                close: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        clientBrief: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
+    customers: z.ZodDefault<z.ZodObject<{
+        segments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodDefault<z.ZodString>;
+            description: z.ZodDefault<z.ZodString>;
+            jobsToBeDone: z.ZodDefault<z.ZodString>;
+            pains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            gains: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            firmographics: z.ZodDefault<z.ZodObject<{
+                industry: z.ZodOptional<z.ZodString>;
+                companySize: z.ZodOptional<z.ZodString>;
+                region: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            valueProp: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    offerings: z.ZodDefault<z.ZodObject<{
+        products: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodDefault<z.ZodString>;
+            description: z.ZodDefault<z.ZodString>;
+            pricingModel: z.ZodDefault<z.ZodEnum<{
+                custom: "custom";
+                "one-time": "one-time";
+                subscription: "subscription";
+                "usage-based": "usage-based";
+            }>>;
+            price: z.ZodDefault<z.ZodNumber>;
+            currency: z.ZodDefault<z.ZodString>;
+            targetSegmentIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            deliveryFeatureId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    roles: z.ZodDefault<z.ZodObject<{
+        roles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            responsibilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            reportsToId: z.ZodOptional<z.ZodString>;
+            heldBy: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    goals: z.ZodDefault<z.ZodObject<{
+        objectives: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+            periodStart: z.ZodString;
+            periodEnd: z.ZodString;
+            keyResults: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+                targetMetric: z.ZodString;
+                currentValue: z.ZodDefault<z.ZodNumber>;
+                targetValue: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    statuses: z.ZodDefault<z.ZodObject<{
+        entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            semanticClass: z.ZodEnum<{
+                execution: "execution";
+                schedule: "schedule";
+                queue: "queue";
+                "delivery.project": "delivery.project";
+                "delivery.milestone": "delivery.milestone";
+                "delivery.task": "delivery.task";
+                "schedule.run": "schedule.run";
+                request: "request";
+            }>;
+            category: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    operations: z.ZodDefault<z.ZodObject<{
+        entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            semanticClass: z.ZodEnum<{
+                sessions: "sessions";
+                notifications: "notifications";
+                schedules: "schedules";
+                executions: "executions";
+                queue: "queue";
+            }>;
+            featureId: z.ZodOptional<z.ZodString>;
+            supportedStatusSemanticClass: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    resourceMappings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        resourceId: z.ZodString;
+        resourceType: z.ZodEnum<{
+            agent: "agent";
+            workflow: "workflow";
+            trigger: "trigger";
+            integration: "integration";
+            external: "external";
+            human_checkpoint: "human_checkpoint";
+        }>;
+        featureIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        entityIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        surfaceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        capabilityIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        techStack: z.ZodOptional<z.ZodObject<{
+            platform: z.ZodString;
+            purpose: z.ZodString;
+            credentialStatus: z.ZodEnum<{
+                pending: "pending";
+                configured: "configured";
+                expired: "expired";
+                missing: "missing";
+            }>;
+            isSystemOfRecord: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 
-declare const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
-  const featuresById = collectIds(model.features, ctx, ['features'], 'Feature')
-  const surfacesById = collectIds(model.navigation.surfaces, ctx, ['navigation', 'surfaces'], 'Surface')
-  collectIds(model.navigation.groups, ctx, ['navigation', 'groups'], 'Navigation group')
-  collectIds(model.resourceMappings, ctx, ['resourceMappings'], 'Resource mapping')
-
-  const resourceMappingsByResourceId = new Map<string, (typeof model.resourceMappings)[number]>()
-  model.resourceMappings.forEach((resourceMapping, index) => {
-    if (resourceMappingsByResourceId.has(resourceMapping.resourceId)) {
-      addIssue(
-        ctx,
-        ['resourceMappings', index, 'resourceId'],
-        `Resource mapping resourceId "${resourceMapping.resourceId}" must be unique`
-      )
-      return
-    }
-
-    resourceMappingsByResourceId.set(resourceMapping.resourceId, resourceMapping)
-  })
-
-  if (model.navigation.defaultSurfaceId && !surfacesById.has(model.navigation.defaultSurfaceId)) {
-    addIssue(
-      ctx,
-      ['navigation', 'defaultSurfaceId'],
-      `Default surface "${model.navigation.defaultSurfaceId}" must reference a declared navigation surface`
-    )
-  }
-
-  model.navigation.groups.forEach((group, groupIndex) => {
-    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
-      if (!surfacesById.has(surfaceId)) {
-        addIssue(
-          ctx,
-          ['navigation', 'groups', groupIndex, 'surfaceIds', surfaceIndex],
-          `Navigation group "${group.id}" references unknown surface "${surfaceId}"`
-        )
-      }
-    })
-  })
-
-  // Feature -> Surface bidirectional validation
-  model.features.forEach((feature, featureIndex) => {
-    feature.surfaceIds.forEach((surfaceId, surfaceIndex) => {
-      const surface = surfacesById.get(surfaceId)
-      if (!surface) {
-        addIssue(
-          ctx,
-          ['features', featureIndex, 'surfaceIds', surfaceIndex],
-          `Feature "${feature.id}" references unknown surface "${surfaceId}"`
-        )
-        return
-      }
-
-      if (!surface.featureIds.includes(feature.id)) {
-        addIssue(
-          ctx,
-          ['features', featureIndex, 'surfaceIds', surfaceIndex],
-          `Feature "${feature.id}" references surface "${surfaceId}" but that surface does not include feature "${feature.id}"`
-        )
-      }
-    })
-
-    // Feature -> Resource bidirectional validation
-    feature.resourceIds.forEach((resourceId, resourceIndex) => {
-      const resourceMapping = resourceMappingsByResourceId.get(resourceId)
-      if (!resourceMapping) {
-        addIssue(
-          ctx,
-          ['features', featureIndex, 'resourceIds', resourceIndex],
-          `Feature "${feature.id}" references unknown resource "${resourceId}"`
-        )
-        return
-      }
-
-      if (!resourceMapping.featureIds.includes(feature.id)) {
-        addIssue(
-          ctx,
-          ['features', featureIndex, 'resourceIds', resourceIndex],
-          `Feature "${feature.id}" references resource "${resourceId}" but that resource mapping does not include feature "${feature.id}"`
-        )
-      }
-    })
-  })
-
-  // Surface -> Feature bidirectional validation and other surface refs
-  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
-    if (surface.parentId && !surfacesById.has(surface.parentId)) {
-      addIssue(
-        ctx,
-        ['navigation', 'surfaces', surfaceIndex, 'parentId'],
-        `Surface "${surface.id}" references unknown parent surface "${surface.parentId}"`
-      )
-    }
-
-    surface.featureIds.forEach((featureId, featureIndex) => {
-      const feature = featuresById.get(featureId)
-      if (!feature) {
-        addIssue(
-          ctx,
-          ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
-          `Surface "${surface.id}" references unknown feature "${featureId}"`
-        )
-        return
-      }
-
-      if (!feature.surfaceIds.includes(surface.id)) {
-        addIssue(
-          ctx,
-          ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
-          `Surface "${surface.id}" references feature "${featureId}" but that feature does not include surface "${surface.id}"`
-        )
-      }
-    })
-
-    // Surface -> Resource bidirectional validation
-    surface.resourceIds.forEach((resourceId, resourceIndex) => {
-      const resourceMapping = resourceMappingsByResourceId.get(resourceId)
-      if (!resourceMapping) {
-        addIssue(
-          ctx,
-          ['navigation', 'surfaces', surfaceIndex, 'resourceIds', resourceIndex],
-          `Surface "${surface.id}" references unknown resource "${resourceId}"`
-        )
-        return
-      }
-
-      if (!resourceMapping.surfaceIds.includes(surface.id)) {
-        addIssue(
-          ctx,
-          ['navigation', 'surfaces', surfaceIndex, 'resourceIds', resourceIndex],
-          `Surface "${surface.id}" references resource "${resourceId}" but that surface does not include resource "${surface.id}"`
-        )
-      }
-    })
-  })
-
-  // Offerings -> CustomerSegment cross-ref: targetSegmentIds must resolve
-  const segmentsById = new Map(model.customers.segments.map((seg) => [seg.id, seg]))
-  model.offerings.products.forEach((product, productIndex) => {
-    product.targetSegmentIds.forEach((segmentId, segmentIndex) => {
-      if (!segmentsById.has(segmentId)) {
-        addIssue(
-          ctx,
-          ['offerings', 'products', productIndex, 'targetSegmentIds', segmentIndex],
-          `Product "${product.id}" references unknown customer segment "${segmentId}"`
-        )
-      }
-    })
-
-    // Offerings -> Feature cross-ref: deliveryFeatureId must resolve (when present)
-    if (product.deliveryFeatureId !== undefined && !featuresById.has(product.deliveryFeatureId)) {
-      addIssue(
-        ctx,
-        ['offerings', 'products', productIndex, 'deliveryFeatureId'],
-        `Product "${product.id}" references unknown delivery feature "${product.deliveryFeatureId}"`
-      )
-    }
-  })
-
-  // Goals -> period-range validation: periodEnd must be strictly after periodStart
-  model.goals.objectives.forEach((objective, index) => {
-    if (objective.periodEnd <= objective.periodStart) {
-      addIssue(
-        ctx,
-        ['goals', 'objectives', index, 'periodEnd'],
-        `Goal "${objective.id}" has periodEnd "${objective.periodEnd}" which must be strictly after periodStart "${objective.periodStart}"`
-      )
-    }
-  })
-
-  // Roles -> reportsToId cross-ref: each reportsToId must resolve to another role in the same collection
-  const rolesById = new Map(model.roles.roles.map((role) => [role.id, role]))
-  model.roles.roles.forEach((role, roleIndex) => {
-    if (role.reportsToId !== undefined && !rolesById.has(role.reportsToId)) {
-      addIssue(
-        ctx,
-        ['roles', 'roles', roleIndex, 'reportsToId'],
-        `Role "${role.id}" references unknown reportsToId "${role.reportsToId}"`
-      )
-    }
-  })
-
-  // ResourceMapping -> Feature and Surface bidirectional validation
-  model.resourceMappings.forEach((resourceMapping, resourceIndex) => {
-    resourceMapping.featureIds.forEach((featureId, featureIndex) => {
-      const feature = featuresById.get(featureId)
-      if (!feature) {
-        addIssue(
-          ctx,
-          ['resourceMappings', resourceIndex, 'featureIds', featureIndex],
-          `Resource mapping "${resourceMapping.id}" references unknown feature "${featureId}"`
-        )
-        return
-      }
-
-      if (!feature.resourceIds.includes(resourceMapping.resourceId)) {
-        addIssue(
-          ctx,
-          ['resourceMappings', resourceIndex, 'featureIds', featureIndex],
-          `Resource mapping "${resourceMapping.id}" references feature "${featureId}" but that feature does not include resource "${resourceMapping.resourceId}"`
-        )
-      }
-    })
-
-    resourceMapping.surfaceIds.forEach((surfaceId, surfaceIndex) => {
-      const surface = surfacesById.get(surfaceId)
-      if (!surface) {
-        addIssue(
-          ctx,
-          ['resourceMappings', resourceIndex, 'surfaceIds', surfaceIndex],
-          `Resource mapping "${resourceMapping.id}" references unknown surface "${surfaceId}"`
-        )
-        return
-      }
-
-      if (!surface.resourceIds.includes(resourceMapping.resourceId)) {
-        addIssue(
-          ctx,
-          ['resourceMappings', resourceIndex, 'surfaceIds', surfaceIndex],
-          `Resource mapping "${resourceMapping.id}" references surface "${surfaceId}" but that surface does not include resource "${resourceMapping.resourceId}"`
-        )
-      }
-    })
-  })
-})
-
-type OrganizationModel = z.infer<typeof OrganizationModelSchema>
-type OrganizationModelSurface = z.infer<typeof SurfaceDefinitionSchema>
+declare const SurfaceDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    path: z.ZodString;
+    surfaceType: z.ZodEnum<{
+        list: "list";
+        settings: "settings";
+        page: "page";
+        dashboard: "dashboard";
+        graph: "graph";
+        detail: "detail";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    icon: z.ZodOptional<z.ZodString>;
+    featureId: z.ZodOptional<z.ZodString>;
+    featureIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    entityIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    resourceIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    capabilityIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    parentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 
-interface EventSourceMessage {
-    id: string;
-    event: string;
-    data: string;
-    retry?: number;
-}
+type OrganizationModel = z.infer<typeof OrganizationModelSchema>;
+type OrganizationModelSurface = z.infer<typeof SurfaceDefinitionSchema>;
 
 interface FetchEventSourceWithTokenRefreshOptions {
     url: string;

package/dist/provider/published.js

@@ -1,11 +1,11 @@
-export { ElevasisFeaturesProvider, FeatureShell, useElevasisFeatures, useOptionalElevasisFeatures } from '../chunk-A2AZY5SF.js';
-export { ElevasisCoreProvider, NotificationProvider, useNotificationAdapter } from '../chunk-P3TFNFZS.js';
+export { ElevasisFeaturesProvider, FeatureShell, useElevasisFeatures, useOptionalElevasisFeatures } from '../chunk-LR5CRY5A.js';
+export { ElevasisCoreProvider, NotificationProvider, useNotificationAdapter } from '../chunk-OUYH2SBS.js';
 import '../chunk-RX4UWZZR.js';
-import '../chunk-SQPM2QDH.js';
+import '../chunk-BHR7IV72.js';
 import '../chunk-SZHARWKU.js';
 import '../chunk-3KMDHCAR.js';
 import '../chunk-NYBEU5TE.js';
-import '../chunk-VDM6DQES.js';
+import '../chunk-R7OJCNL3.js';
 import '../chunk-2IFYDILW.js';
 import '../chunk-Q7DJKLEN.js';
 import '../chunk-7YQKVWSD.js';
@@ -14,7 +14,7 @@ export { AppearanceProvider, useAppearance } from '../chunk-QJ2KCHKX.js';
 import '../chunk-HQ7M6PBW.js';
 import '../chunk-DT3QYZVU.js';
 import '../chunk-RNP5R5I3.js';
-import '../chunk-GCBWGGI6.js';
+import '../chunk-OD7GWIZS.js';
 import '../chunk-KRWALB24.js';
 import '../chunk-SLH2QLKV.js';
 import '../chunk-DK2HVHCY.js';
@@ -22,3 +22,4 @@ import '../chunk-DD3CCMCZ.js';
 import '../chunk-QHSW4WHM.js';
 export { ElevasisServiceProvider, useElevasisServices } from '../chunk-IRW7JMQ4.js';
 import '../chunk-BRJ3QZ4E.js';
+import '../chunk-I2KLQ2HA.js';

package/dist/router/context.js

@@ -1 +1,2 @@
 export { RouterProvider, useRouterContext } from '../chunk-Q7DJKLEN.js';
+import '../chunk-I2KLQ2HA.js';

package/dist/router/index.js

@@ -1,2 +1,3 @@
 export { ScrollToTop, TanStackRouterBridge } from '../chunk-2IFYDILW.js';
 export { RouterProvider, useRouterContext } from '../chunk-Q7DJKLEN.js';
+import '../chunk-I2KLQ2HA.js';

package/dist/sse/index.d.ts

@@ -1,9 +1,4 @@
-interface EventSourceMessage {
-    id: string;
-    event: string;
-    data: string;
-    retry?: number;
-}
+import { EventSourceMessage } from '@microsoft/fetch-event-source';
 
 interface FetchEventSourceWithTokenRefreshOptions {
     url: string;

package/dist/sse/index.js

@@ -1,6 +1,6 @@
+import '../chunk-I2KLQ2HA.js';
 import { fetchEventSource } from '@microsoft/fetch-event-source';
 
-// src/sse/fetchEventSourceWithTokenRefresh.ts
 async function fetchEventSourceWithTokenRefresh(options) {
   const {
     url,

package/dist/supabase/index.js

@@ -1,2 +1,3 @@
 export { getSupabaseClient, useSupabase } from '../chunk-BRXELOHC.js';
 import '../chunk-BRJ3QZ4E.js';
+import '../chunk-I2KLQ2HA.js';