@xnetjs/data 0.0.2 → 0.1.0

package/dist/map-RG5Y3CPC.js

@@ -0,0 +1,10 @@
+import {
+  MapSchema
+} from "./chunk-NI4FHG2K.js";
+import "./chunk-OCMSAKWV.js";
+import "./chunk-T5AZAOG5.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  MapSchema
+};

package/dist/media-asset-QTCGLIZA.js

@@ -0,0 +1,8 @@
+import {
+  MediaAssetSchema
+} from "./chunk-3J3HILXO.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  MediaAssetSchema
+};

package/dist/memory-PNRTMBZO.js

@@ -0,0 +1,12 @@
+import {
+  MEMORY_ITEM_SCHEMA_IRI,
+  MEMORY_KINDS,
+  MemoryItemSchema
+} from "./chunk-GU6THOAB.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  MEMORY_ITEM_SCHEMA_IRI,
+  MEMORY_KINDS,
+  MemoryItemSchema
+};

package/dist/metric-65SVOX5C.js

@@ -0,0 +1,10 @@
+import {
+  MetricSchema
+} from "./chunk-U64CW73O.js";
+import "./chunk-OCMSAKWV.js";
+import "./chunk-T5AZAOG5.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  MetricSchema
+};

package/dist/milestone-XEO6ZGDG.js

@@ -0,0 +1,12 @@
+import {
+  MILESTONE_SCHEMA_IRI,
+  MilestoneSchema
+} from "./chunk-OGJCRNGE.js";
+import "./chunk-OCMSAKWV.js";
+import "./chunk-T5AZAOG5.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  MILESTONE_SCHEMA_IRI,
+  MilestoneSchema
+};

package/dist/moderation-FFHETMRB.js

@@ -0,0 +1,30 @@
+import {
+  AbuseReportSchema,
+  AppealSchema,
+  CommunityNoteSchema,
+  ContentProvenanceSchema,
+  MessageRequestSchema,
+  ModerationLabelSchema,
+  NoteRatingSchema,
+  PolicyListSchema,
+  PolicySubscriptionSchema,
+  PublicInteractionPolicySchema,
+  QualitySignalSchema,
+  ReviewTaskSchema
+} from "./chunk-S6U6TCMN.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  AbuseReportSchema,
+  AppealSchema,
+  CommunityNoteSchema,
+  ContentProvenanceSchema,
+  MessageRequestSchema,
+  ModerationLabelSchema,
+  NoteRatingSchema,
+  PolicyListSchema,
+  PolicySubscriptionSchema,
+  PublicInteractionPolicySchema,
+  QualitySignalSchema,
+  ReviewTaskSchema
+};

package/dist/observation-2Y3QKUXM.js

@@ -0,0 +1,10 @@
+import {
+  ObservationSchema
+} from "./chunk-W7EBL7ZU.js";
+import "./chunk-OCMSAKWV.js";
+import "./chunk-T5AZAOG5.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  ObservationSchema
+};

package/dist/page-2V27JGKJ.js

@@ -0,0 +1,10 @@
+import {
+  PageSchema
+} from "./chunk-ZLU4Y3O2.js";
+import "./chunk-OCMSAKWV.js";
+import "./chunk-T5AZAOG5.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  PageSchema
+};

package/dist/posting-GBOSZCMZ.js

@@ -0,0 +1,12 @@
+import {
+  POSTING_SCHEMA_IRI,
+  PostingSchema
+} from "./chunk-JDFNMFOZ.js";
+import "./chunk-OCMSAKWV.js";
+import "./chunk-T5AZAOG5.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  POSTING_SCHEMA_IRI,
+  PostingSchema
+};

package/dist/profile-BLLDWIDK.js

@@ -0,0 +1,8 @@
+import {
+  ProfileSchema
+} from "./chunk-DCTRX6II.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  ProfileSchema
+};

package/dist/project-CQL5LN26.js

@@ -0,0 +1,10 @@
+import {
+  ProjectSchema
+} from "./chunk-XROI44ZP.js";
+import "./chunk-OCMSAKWV.js";
+import "./chunk-T5AZAOG5.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  ProjectSchema
+};

package/dist/query-ast-C3m6kZYv.d.ts

@@ -0,0 +1,226 @@
+import { S as SchemaIRI, c as SortDirection, N as NodeQueryPageCountMode, P as PropertyBuilder, I as InferCreateProps, D as DefinedSchema, d as SystemOrderField } from './types-S-BJAKyK.js';
+
+/**
+ * Canonical query AST for advanced Node reads.
+ *
+ * This module is intentionally storage-agnostic. It provides serializable query
+ * shapes, typed helper constructors, and validation/planning metadata for the
+ * future relation, aggregate, query-set, and pattern-query surfaces.
+ */
+
+declare const QUERY_AST_VERSION: 1;
+type QueryASTVersion = typeof QUERY_AST_VERSION;
+type QueryASTField<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>> = Extract<keyof InferCreateProps<P>, string>;
+type QueryASTSchemaInput<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>> = SchemaIRI | DefinedSchema<P>;
+type QueryASTOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'between' | 'in' | 'contains' | 'startsWith' | 'isNull' | 'isNotNull';
+type QueryASTComparisonPredicate = {
+    kind: 'comparison';
+    field: string;
+    op: QueryASTOperator;
+    value?: unknown;
+    values?: unknown[];
+};
+type QueryASTCompoundPredicate = {
+    kind: 'and' | 'or';
+    predicates: QueryASTPredicate[];
+};
+type QueryASTNotPredicate = {
+    kind: 'not';
+    predicate: QueryASTPredicate;
+};
+type QueryASTPredicate = QueryASTComparisonPredicate | QueryASTCompoundPredicate | QueryASTNotPredicate;
+type QueryASTOrderBy = {
+    field: string;
+    direction: SortDirection;
+};
+type QueryASTPage = {
+    first?: number;
+    after?: string;
+    offset?: number;
+    count?: NodeQueryPageCountMode;
+};
+type QueryASTRelationDirection = 'outbound' | 'inbound';
+type QueryASTRelationInclude = {
+    kind: 'relation-include';
+    direction: QueryASTRelationDirection;
+    field: string;
+    targetSchemaId: SchemaIRI;
+    query: QueryASTNodeQuery;
+    cardinality: 'one' | 'many';
+    required?: boolean;
+};
+type QueryASTIncludes = Record<string, QueryASTRelationInclude>;
+type QueryASTAggregateFunction = 'count' | 'countDistinct' | 'sum' | 'avg' | 'min' | 'max';
+type QueryASTAggregate = {
+    kind: 'aggregate';
+    alias: string;
+    function: QueryASTAggregateFunction;
+    field?: string;
+    groupBy?: string[];
+    having?: QueryASTPredicate;
+};
+type QueryASTQuerySetAggregate = {
+    kind: 'query-set-aggregate';
+    alias: string;
+    query: string;
+    function: QueryASTAggregateFunction;
+    field?: string;
+};
+type QueryASTNodeQuery = {
+    version: QueryASTVersion;
+    kind: 'node';
+    schemaId: SchemaIRI;
+    predicate?: QueryASTPredicate;
+    orderBy?: QueryASTOrderBy[];
+    page?: QueryASTPage;
+    include?: QueryASTIncludes;
+    aggregates?: QueryASTAggregate[];
+};
+type QueryASTQuerySet = {
+    version: QueryASTVersion;
+    kind: 'query-set';
+    mode: 'batch' | 'dashboard';
+    queries: Record<string, QueryASTNodeQuery>;
+    aggregates?: QueryASTQuerySetAggregate[];
+};
+type QueryAST = QueryASTNodeQuery | QueryASTQuerySet;
+type QueryASTNodeQueryOptions<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>> = {
+    where?: QueryASTPredicate | QueryASTPredicate[];
+    orderBy?: Partial<Record<QueryASTField<P> | SystemOrderField, SortDirection>>;
+    page?: QueryASTPage;
+    include?: QueryASTIncludes;
+    aggregates?: QueryASTAggregate[];
+};
+type QueryASTRelationIncludeOptions<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>> = QueryASTNodeQueryOptions<P> & {
+    cardinality?: 'one' | 'many';
+    required?: boolean;
+};
+type QueryASTValidationError = {
+    path: string;
+    code: string;
+    message: string;
+    value?: unknown;
+};
+type QueryASTValidationResult = {
+    valid: boolean;
+    errors: QueryASTValidationError[];
+};
+type QueryASTRelationIndexRequirement = {
+    schemaId: SchemaIRI;
+    property: string;
+    direction: QueryASTRelationDirection;
+    targetSchemaId: SchemaIRI;
+    reason: 'include';
+};
+type QueryASTAggregatePlan = {
+    path: string;
+    alias: string;
+    function: QueryASTAggregateFunction;
+    strategy: 'node-count' | 'scalar-scan' | 'distinct-scan';
+    requiredFields: string[];
+    groupBy: string[];
+    canUseScalarIndex: boolean;
+};
+type QueryASTAggregateGroup = {
+    key: Record<string, unknown>;
+    rowCount: number;
+    value: unknown;
+};
+type QueryASTAggregateResult = {
+    alias: string;
+    function: QueryASTAggregateFunction;
+    field?: string;
+    groupBy: string[];
+    rowCount: number;
+    value: unknown;
+    groups?: QueryASTAggregateGroup[];
+};
+type QueryASTAggregateExecution = {
+    scope: 'loaded-snapshot';
+    rowCount: number;
+    results: Record<string, QueryASTAggregateResult>;
+};
+type QueryASTPlannerGate = {
+    validation: QueryASTValidationResult;
+    relationIndexRequirements: QueryASTRelationIndexRequirement[];
+    aggregatePlans: QueryASTAggregatePlan[];
+    useFindReady: boolean;
+    blockers: string[];
+};
+type SavedViewFeedLayout = 'list' | 'grid';
+type SavedViewFeedDensity = 'compact' | 'cozy' | 'comfortable';
+type SavedViewPresentationHintMode = 'table' | 'cards' | 'timeline' | 'canvas' | 'graph' | 'feed';
+/**
+ * Optional rendering hint persisted with a saved view so specialized views
+ * (for example media feeds) can open in their intended presentation.
+ */
+type SavedViewPresentationHint = {
+    mode?: SavedViewPresentationHintMode;
+    feedLayout?: SavedViewFeedLayout;
+    feedDensity?: SavedViewFeedDensity;
+};
+type SavedViewDescriptor = {
+    version: QueryASTVersion;
+    title: string;
+    query: QueryAST;
+    description?: string;
+    scope?: 'user' | 'workspace' | 'database';
+    presentation?: SavedViewPresentationHint;
+};
+declare function eq<P extends Record<string, PropertyBuilder>, K extends QueryASTField<P> = QueryASTField<P>>(field: K, value: InferCreateProps<P>[K]): QueryASTPredicate;
+declare function neq<P extends Record<string, PropertyBuilder>, K extends QueryASTField<P> = QueryASTField<P>>(field: K, value: InferCreateProps<P>[K]): QueryASTPredicate;
+declare function gt<P extends Record<string, PropertyBuilder>, K extends QueryASTField<P> = QueryASTField<P>>(field: K, value: InferCreateProps<P>[K]): QueryASTPredicate;
+declare function gte<P extends Record<string, PropertyBuilder>, K extends QueryASTField<P> = QueryASTField<P>>(field: K, value: InferCreateProps<P>[K]): QueryASTPredicate;
+declare function lt<P extends Record<string, PropertyBuilder>, K extends QueryASTField<P> = QueryASTField<P>>(field: K, value: InferCreateProps<P>[K]): QueryASTPredicate;
+declare function lte<P extends Record<string, PropertyBuilder>, K extends QueryASTField<P> = QueryASTField<P>>(field: K, value: InferCreateProps<P>[K]): QueryASTPredicate;
+declare function between<P extends Record<string, PropertyBuilder>, K extends QueryASTField<P> = QueryASTField<P>>(field: K, from: InferCreateProps<P>[K], to: InferCreateProps<P>[K]): QueryASTPredicate;
+declare function includesAny<P extends Record<string, PropertyBuilder>, K extends QueryASTField<P> = QueryASTField<P>>(field: K, values: InferCreateProps<P>[K][]): QueryASTPredicate;
+declare function contains<P extends Record<string, PropertyBuilder>, K extends QueryASTField<P> = QueryASTField<P>>(field: K, value: string): QueryASTPredicate;
+declare function startsWith<P extends Record<string, PropertyBuilder>, K extends QueryASTField<P> = QueryASTField<P>>(field: K, value: string): QueryASTPredicate;
+declare function isNull<P extends Record<string, PropertyBuilder>, K extends QueryASTField<P> = QueryASTField<P>>(field: K): QueryASTPredicate;
+declare function isNotNull<P extends Record<string, PropertyBuilder>, K extends QueryASTField<P> = QueryASTField<P>>(field: K): QueryASTPredicate;
+declare function and(...predicates: QueryASTPredicate[]): QueryASTPredicate;
+declare function or(...predicates: QueryASTPredicate[]): QueryASTPredicate;
+declare function not(predicate: QueryASTPredicate): QueryASTPredicate;
+declare function queryOperators<P extends Record<string, PropertyBuilder>>(): {
+    eq: <K extends QueryASTField<P>>(field: K, value: InferCreateProps<P>[K]) => QueryASTPredicate;
+    neq: <K extends QueryASTField<P>>(field: K, value: InferCreateProps<P>[K]) => QueryASTPredicate;
+    gt: <K extends QueryASTField<P>>(field: K, value: InferCreateProps<P>[K]) => QueryASTPredicate;
+    gte: <K extends QueryASTField<P>>(field: K, value: InferCreateProps<P>[K]) => QueryASTPredicate;
+    lt: <K extends QueryASTField<P>>(field: K, value: InferCreateProps<P>[K]) => QueryASTPredicate;
+    lte: <K extends QueryASTField<P>>(field: K, value: InferCreateProps<P>[K]) => QueryASTPredicate;
+    between: <K extends QueryASTField<P>>(field: K, from: InferCreateProps<P>[K], to: InferCreateProps<P>[K]) => QueryASTPredicate;
+    includesAny: <K extends QueryASTField<P>>(field: K, values: InferCreateProps<P>[K][]) => QueryASTPredicate;
+    contains: <K extends QueryASTField<P>>(field: K, value: string) => QueryASTPredicate;
+    startsWith: <K extends QueryASTField<P>>(field: K, value: string) => QueryASTPredicate;
+    isNull: <K extends QueryASTField<P>>(field: K) => QueryASTPredicate;
+    isNotNull: <K extends QueryASTField<P>>(field: K) => QueryASTPredicate;
+};
+declare function defineNodeQueryAST<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>>(schema: QueryASTSchemaInput<P>, options?: QueryASTNodeQueryOptions<P>): QueryASTNodeQuery;
+declare function follow<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>>(schema: QueryASTSchemaInput<P>, field: QueryASTField<P>, options?: QueryASTRelationIncludeOptions<P>): QueryASTRelationInclude;
+declare function from<P extends Record<string, PropertyBuilder> = Record<string, PropertyBuilder>>(schema: QueryASTSchemaInput<P>, field: QueryASTField<P>, options?: QueryASTRelationIncludeOptions<P>): QueryASTRelationInclude;
+declare function count(alias?: string): QueryASTAggregate;
+declare function countDistinct(field: string, alias?: string): QueryASTAggregate;
+declare function sum(field: string, alias?: string): QueryASTAggregate;
+declare function avg(field: string, alias?: string): QueryASTAggregate;
+declare function min(field: string, alias?: string): QueryASTAggregate;
+declare function max(field: string, alias?: string): QueryASTAggregate;
+declare function groupBy(aggregate: QueryASTAggregate, ...fields: string[]): QueryASTAggregate;
+declare function having(aggregate: QueryASTAggregate, predicate: QueryASTPredicate): QueryASTAggregate;
+declare function defineQuerySetAST(queries: Record<string, QueryASTNodeQuery>, options?: {
+    mode?: QueryASTQuerySet['mode'];
+    aggregates?: QueryASTQuerySetAggregate[];
+}): QueryASTQuerySet;
+declare function dashboardQuerySet(queries: Record<string, QueryASTNodeQuery>, aggregates?: QueryASTQuerySetAggregate[]): QueryASTQuerySet;
+declare function querySetCount(query: string, alias?: string): QueryASTQuerySetAggregate;
+declare function defineSavedViewDescriptor(descriptor: Omit<SavedViewDescriptor, 'version'>): SavedViewDescriptor;
+declare function matchesQueryASTLoadedRow(row: unknown, predicate: QueryASTPredicate): boolean;
+declare function filterQueryASTLoadedRows<T>(rows: readonly T[], predicate: QueryASTPredicate | undefined): T[];
+declare function executeQueryASTLoadedAggregates(query: QueryASTNodeQuery, rows: readonly unknown[]): QueryASTAggregateExecution;
+declare function validateQueryAST(value: unknown): QueryASTValidationResult;
+declare function validateSavedViewDescriptor(value: unknown): QueryASTValidationResult;
+declare function planQueryASTAggregates(ast: QueryAST): QueryASTAggregatePlan[];
+declare function getQueryASTRelationIndexRequirements(ast: QueryAST): QueryASTRelationIndexRequirement[];
+declare function evaluateQueryASTPlannerGate(value: unknown): QueryASTPlannerGate;
+
+export { from as $, type QueryASTAggregateExecution as A, type QueryASTPlannerGate as B, type SavedViewPresentationHint as C, type SavedViewPresentationHintMode as D, type SavedViewFeedLayout as E, type SavedViewFeedDensity as F, QUERY_AST_VERSION as G, eq as H, neq as I, gt as J, gte as K, lt as L, lte as M, between as N, includesAny as O, contains as P, type QueryASTVersion as Q, startsWith as R, type SavedViewDescriptor as S, isNull as T, isNotNull as U, and as V, or as W, not as X, queryOperators as Y, defineNodeQueryAST as Z, follow as _, type QueryASTField as a, count as a0, countDistinct as a1, sum as a2, avg as a3, min as a4, max as a5, groupBy as a6, having as a7, defineQuerySetAST as a8, dashboardQuerySet as a9, querySetCount as aa, defineSavedViewDescriptor as ab, validateQueryAST as ac, validateSavedViewDescriptor as ad, planQueryASTAggregates as ae, executeQueryASTLoadedAggregates as af, filterQueryASTLoadedRows as ag, getQueryASTRelationIndexRequirements as ah, matchesQueryASTLoadedRow as ai, evaluateQueryASTPlannerGate as aj, type QueryASTSchemaInput as b, type QueryASTOperator as c, type QueryASTComparisonPredicate as d, type QueryASTCompoundPredicate as e, type QueryASTNotPredicate as f, type QueryASTPredicate as g, type QueryASTOrderBy as h, type QueryASTPage as i, type QueryASTRelationDirection as j, type QueryASTRelationInclude as k, type QueryASTIncludes as l, type QueryASTAggregateFunction as m, type QueryASTAggregate as n, type QueryASTQuerySetAggregate as o, type QueryASTNodeQuery as p, type QueryASTQuerySet as q, type QueryAST as r, type QueryASTNodeQueryOptions as s, type QueryASTRelationIncludeOptions as t, type QueryASTValidationError as u, type QueryASTValidationResult as v, type QueryASTRelationIndexRequirement as w, type QueryASTAggregatePlan as x, type QueryASTAggregateGroup as y, type QueryASTAggregateResult as z };

package/dist/reaction-T2DTJBBV.js

@@ -0,0 +1,10 @@
+import {
+  ReactionSchema
+} from "./chunk-Y3S5SRVM.js";
+import "./chunk-OCMSAKWV.js";
+import "./chunk-T5AZAOG5.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  ReactionSchema
+};

package/dist/registry-DunPv__d.d.ts

@@ -0,0 +1,99 @@
+import { P as PropertyBuilder, D as DefinedSchema, S as SchemaIRI, a as Schema, b as ParsedSchemaIRI } from './types-S-BJAKyK.js';
+
+/**
+ * Schema Registry - Runtime lookup for schema definitions.
+ *
+ * The registry provides:
+ * - Registration of custom schemas
+ * - Lookup by schema IRI
+ * - Lazy loading of built-in schemas
+ * - Validation that a node matches its schema
+ */
+
+/**
+ * Schema Registry for runtime schema lookup.
+ */
+declare class SchemaRegistry {
+    private schemas;
+    private loadingPromises;
+    private remoteResolver;
+    /**
+     * Register a custom schema.
+     *
+     * @param schema - The defined schema to register
+     * @throws If a schema with this IRI is already registered
+     */
+    register<P extends Record<string, PropertyBuilder>>(schema: DefinedSchema<P>): void;
+    /**
+     * Get a schema by IRI.
+     * For built-in schemas, this will lazy-load them on first access.
+     *
+     * @param iri - The schema IRI
+     * @returns The schema, or undefined if not found
+     */
+    get(iri: SchemaIRI): Promise<DefinedSchema | undefined>;
+    /**
+     * Get a schema synchronously (only works for already-loaded schemas).
+     *
+     * @param iri - The schema IRI
+     * @returns The schema, or undefined if not loaded
+     */
+    getSync(iri: SchemaIRI): DefinedSchema | undefined;
+    /**
+     * Check if a schema is registered (either loaded or built-in).
+     */
+    has(iri: SchemaIRI): boolean;
+    /**
+     * Check if a schema is a built-in schema.
+     */
+    isBuiltIn(iri: SchemaIRI): boolean;
+    /**
+     * Get all registered schema IRIs (including built-in).
+     */
+    getAllIRIs(): SchemaIRI[];
+    /**
+     * Unregister a custom schema.
+     * Built-in schemas cannot be unregistered.
+     *
+     * @param iri - The schema IRI to unregister
+     * @returns true if the schema was unregistered
+     */
+    unregister(iri: SchemaIRI): boolean;
+    /**
+     * Clear all custom schemas (keeps built-in schemas).
+     */
+    clear(): void;
+    /**
+     * Set a remote resolver for fetching schemas by IRI.
+     * When a schema is not found locally, the resolver is queried.
+     */
+    setRemoteResolver(resolver: (iri: SchemaIRI) => Promise<Schema | null>): void;
+    /**
+     * Get the version of a registered schema.
+     *
+     * @param iri - The schema IRI (versioned or unversioned)
+     * @returns The version string, or undefined if not found
+     */
+    getVersion(iri: SchemaIRI): string | undefined;
+    /**
+     * Get all versions of a schema by its base name.
+     *
+     * @param baseIRI - The unversioned base IRI (e.g., 'xnet://xnet.fyi/Task')
+     * @returns Array of versioned schemas, sorted by version
+     */
+    getAllVersions(baseIRI: SchemaIRI): Array<{
+        iri: SchemaIRI;
+        version: string;
+        schema: DefinedSchema;
+    }>;
+    /**
+     * Parse a schema IRI into its components.
+     */
+    parseIRI(iri: SchemaIRI): ParsedSchemaIRI;
+}
+/**
+ * Default global schema registry instance.
+ */
+declare const schemaRegistry: SchemaRegistry;
+
+export { SchemaRegistry as S, schemaRegistry as s };

package/dist/saved-view-4R2DBCL3.js

@@ -0,0 +1,10 @@
+import {
+  SavedViewSchema
+} from "./chunk-ZZ6TWKGS.js";
+import "./chunk-OCMSAKWV.js";
+import "./chunk-T5AZAOG5.js";
+import "./chunk-EBNMV2VO.js";
+import "./chunk-RL64OJJ5.js";
+export {
+  SavedViewSchema
+};