@plitzi/sdk-shared 0.30.19

package/dist/types/DataSourceTypes.d.ts

@@ -0,0 +1,56 @@
+import { Element, Schema } from './SchemaTypes';
+import { default as useDataSource } from '../dataSource/hooks/useDataSource';
+import { Field, RuleValue } from '@plitzi/plitzi-ui/QueryBuilder';
+import { Context } from 'react';
+export type DataSourceUtilityParams<TParams = string | boolean | number> = Record<string, {
+    type?: DataSourceUtilityParamType | ((params: DataSourceUtilityParamsValue<TParams>) => DataSourceUtilityParamType);
+    label?: string;
+    description?: string;
+    defaultValue?: string | boolean | number;
+    disabled?: boolean | ((params: DataSourceUtilityParamsValue<TParams>) => boolean);
+    options?: {
+        label: string;
+        value: string;
+    }[];
+}>;
+export type DataSourceUtilityParamsValue<T = string | boolean | number> = Record<keyof DataSourceUtility<T>['params'], T>;
+export type DataSourceUtilityParamType = 'text' | 'select' | 'textarea' | 'checkbox' | 'codemirror-text';
+export type DataSourceUtility<TSource = any, TSourceReturn = string | boolean | number, TParams = string | boolean | number> = {
+    action: string;
+    title: string;
+    type: 'utility' | 'unknown';
+    params: DataSourceUtilityParams<TParams>;
+    preview: Record<string, string>;
+    callback: (source: TSource, params: DataSourceUtilityParamsValue<TParams>, element: Partial<Element>, dataSources?: Record<string, any>) => TSourceReturn;
+};
+export type SourceField = {
+    path: string;
+    name: string;
+    inputType?: Field['inputType'];
+    values?: {
+        value: RuleValue;
+        label: 'string';
+    }[];
+};
+export type SourceMeta = {
+    id?: string;
+    name: string;
+    source?: string;
+    fields?: SourceField[] | (() => SourceField[] | Promise<SourceField[]>);
+};
+export type Source<T = unknown> = {
+    id: string;
+    meta: SourceMeta;
+    context: Context<T>;
+};
+export type DataSourceContextValue = {
+    useDataSource: typeof useDataSource;
+    addSource: <T = unknown>(id: string, meta?: SourceMeta) => Context<T>;
+    updateFields: (id: string, fields: SourceMeta['fields']) => void;
+    removeSource: (id: string) => void;
+    getSources: {
+        (id: string): Source | undefined;
+        (): Record<string, Source>;
+    };
+    getSourcesByElementId: (schemaFlat?: Schema['flat'], id?: string) => Record<string, Source>;
+};

package/dist/types/DevToolsTypes.d.ts

@@ -0,0 +1,44 @@
+import { InteractionNode, InteractionStatus } from './InteractionTypes';
+import { NavigationStatus } from './NavigationTypes';
+import { ElementInteraction } from './SchemaTypes';
+import { ReactNode } from 'react';
+export type LogType = 'info' | 'warning' | 'danger' | 'success' | 'custom';
+export type LogCategory = 'navigation' | 'interactions' | 'store';
+export type LogNavigation = {
+    category: 'navigation';
+    params: {
+        status: NavigationStatus;
+        elementId: string;
+    };
+};
+export type LogEventBridge = {
+    category: 'eventBridge';
+    params: Record<string, unknown>;
+};
+export type LogInteraction = {
+    category: 'interactions';
+    params: {
+        elementId: string;
+        startTime: number;
+        endTime: number;
+        node: ElementInteraction;
+        status: InteractionStatus;
+        nodes: Record<string, InteractionNode>;
+    };
+};
+export type LogStore = {
+    category: 'store';
+    params: {
+        storeName: string;
+        path: string | undefined;
+        prev: unknown;
+        next: unknown;
+    };
+};
+export type LogParams = LogNavigation['params'] | LogInteraction['params'] | LogEventBridge['params'] | LogStore['params'];
+export type Log = {
+    logType: string;
+    message: ReactNode;
+    time?: string;
+} & (LogInteraction | LogNavigation | LogEventBridge | LogStore);
+export type ProviderCallback = (...args: unknown[]) => Record<string, unknown>;

package/dist/types/ElementTypes.d.ts

@@ -0,0 +1,35 @@
+import { Asset, PluginManifest, PluginSchema } from './PluginTypes';
+import { Element } from './SchemaTypes';
+import { ReactNode } from 'react';
+export type ElementLayoutType = 'layout' | 'segment' | 'element' | 'reference';
+export type ElementLayout = {
+    bodyChildren: ReactNode;
+    containerId: string;
+    referenceId: string;
+    rootId: string;
+    type: ElementLayoutType;
+};
+export type InternalPropsExtension<T extends Record<Exclude<string, 'id' | 'rootId'>, unknown> = Record<Exclude<string, 'id' | 'rootId'>, unknown>> = T;
+export type InternalPropsSTG0<T extends InternalPropsExtension = InternalPropsExtension> = {
+    id: string;
+    rootId?: string;
+} & T;
+export type InternalPropsSTG1<T extends InternalPropsExtension = InternalPropsExtension> = InternalPropsSTG0<T> & {
+    plitziElementLayout?: ElementLayout;
+    attributes?: Element['attributes'];
+};
+export type ComponentDefinition = Pick<PluginSchema, 'attributes' | 'builder' | 'definition' | 'defaultStyle' | 'initialItems'> & {
+    assets: Asset[];
+    assetsSettings: Omit<Asset, 'isMain'>[];
+    manifest: PluginManifest;
+    market: Omit<PluginManifest, 'name'> & {
+        category: string;
+    };
+    settings: {
+        [key: string]: string | number | boolean;
+    };
+    type: string;
+    subPlugins: string[];
+    resource: string;
+    isMain?: boolean;
+} & PluginManifest['runtime'];

package/dist/types/EventBridgeTypes.d.ts

@@ -0,0 +1,5 @@
+export type EventBridgeContextValue<T = any> = {
+    eventBridge: T;
+};
+export type EventBridgeModule = 'main' | 'builder' | 'segment' | 'template' | 'interaction' | 'element';
+export type EventBridgeEvent = 'schemaAddPage' | 'schemaHomePage' | 'schemaUpdatePage' | 'schemaRemovePage' | 'schemaAddPageFolder' | 'schemaUpdatePageFolder' | 'schemaRemovePageFolder' | 'schemaUpdateSettings' | 'schemaUpdate' | 'schemaAddElement' | 'schemaUpdateElement' | 'schemaRemoveElement' | 'schemaMoveElement' | 'schemaCloneElement' | 'schemaAddVariable' | 'schemaUpdateVariable' | 'schemaRemoveVariable' | 'schemaAddTemplate' | 'styleUpdate' | 'styleAddSelector' | 'styleUpdateSelector' | 'styleRemoveSelector' | 'styleAddSelectorVariable' | 'styleUpdateSelectorVariable' | 'styleRemoveSelectorVariable' | 'styleAddVariable' | 'styleUpdateVariable' | 'styleRemoveVariable' | 'styleAddTemplate' | 'styleUpdateSettings' | 'builderSetBaseContext' | 'builderSetSelected' | 'builderSetHovered';

package/dist/types/InteractionTypes.d.ts

@@ -0,0 +1,101 @@
+import { ElementInteraction } from './SchemaTypes';
+import { RuleValue } from '@plitzi/plitzi-ui/QueryBuilder';
+export type InteractionCallbackType = 'trigger' | 'globalCallback' | 'callback' | 'utility';
+export type InteractionStatus = 'completed' | 'skipped';
+export type InteractionNodeStatus = 'success' | 'failed' | 'skipped' | 'disabled';
+export type InteractionPostCallback<T extends Record<string, unknown> = Record<string, unknown>> = (params: InteractionCallbackParamValues<T>, callbackResult?: unknown) => unknown;
+export type PostCallbackNode<T extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    callback?: InteractionPostCallback<T>;
+    params: ElementInteraction['params'];
+};
+export type InteractionNode = {
+    node: ElementInteraction;
+    status: InteractionNodeStatus;
+    postCallbacks: PostCallbackNode[];
+    result?: unknown;
+    startTime: number;
+    endTime: number;
+    whenParams?: Record<string, RuleValue>;
+};
+export type InteractionParamType = 'boolean' | 'select' | 'text' | 'textarea' | 'codemirror-text' | 'codemirror-json';
+export type InteractionCallbackParamValues<T extends Record<string, unknown> = Record<string, unknown>> = T;
+export type InteractionCallbackParam<T extends Record<string, unknown> = Record<string, unknown>> = {
+    canBind?: boolean;
+    label?: string;
+    when?: boolean | ((params: InteractionCallbackParamValues<T>) => boolean);
+} & ({
+    type: 'text';
+    defaultValue?: string | number;
+} | {
+    type: 'textarea';
+    defaultValue?: string | number;
+} | {
+    type: 'codemirror-text';
+    defaultValue?: string;
+} | {
+    type: 'codemirror-json';
+    defaultValue?: string;
+} | {
+    type: 'boolean';
+    defaultValue?: boolean;
+} | {
+    type: 'select';
+    defaultValue?: string;
+    options: {
+        label: string;
+        value: string;
+    }[] | ((params: InteractionCallbackParamValues<T>) => {
+        label: string;
+        value: string;
+    }[]);
+} | {
+    type: (params: InteractionCallbackParamValues<T>) => InteractionParamType;
+    defaultValue?: string | number | boolean;
+    options?: {
+        label: string;
+        value: string;
+    }[] | ((params: InteractionCallbackParamValues<T>) => {
+        label: string;
+        value: string;
+    }[]);
+});
+export type InteractionCallbackPreview = string | Record<string, unknown>;
+export type InteractionCallbackPreviews = Record<string, InteractionCallbackPreview>;
+export type InteractionCallback<T extends Record<string, unknown> = Record<string, unknown>> = {
+    elementId?: string;
+    action: string;
+    title: string;
+    type: InteractionCallbackType;
+    enabled?: boolean;
+    params: Record<keyof T, InteractionCallbackParam<T>> | ((params: InteractionCallbackParamValues<T>) => Record<keyof T, InteractionCallbackParam<T>>);
+    callback?: (params: InteractionCallbackParamValues<T>) => unknown;
+    postCallback?: InteractionPostCallback<T>;
+    preview?: InteractionCallbackPreviews | ((params: InteractionCallbackParamValues<T>) => InteractionCallbackPreviews);
+};
+export type Trigger<T extends Record<string, unknown> = Record<string, unknown>> = {
+    title: string;
+    preview?: InteractionCallbackPreviews | ((params: T) => InteractionCallbackPreviews);
+    params: {
+        [K in keyof T]: InteractionCallbackParam<T>;
+    } | ((params: T) => {
+        [K in keyof T]: InteractionCallbackParam<T>;
+    });
+};
+export type Subscriptor<T extends Record<string, unknown> = Record<string, unknown>> = {
+    getAdditionalParams?: (params?: T) => {
+        dataSource?: Record<string, unknown>;
+    };
+    id: string;
+    triggers: Record<string, Trigger<T>>;
+};
+export type InteractionsContextValue<TManager = any> = {
+    interactionsManager: TManager;
+    useInteractions: <T extends Record<string, unknown> = Record<string, unknown>>(props: {
+        id: string;
+        interactions?: Record<string, ElementInteraction>;
+        triggers?: Record<string, InteractionCallback<T>>;
+        callbacks?: Record<string, InteractionCallback<T>>;
+        getAdditionalParams?: Subscriptor<T>['getAdditionalParams'];
+    }) => void;
+};

package/dist/types/McpTypes.d.ts

@@ -0,0 +1,164 @@
+import { PageFolder, SchemaVariable, DropPosition } from './SchemaTypes';
+import { DisplayMode, StyleCategory, StyleItem, StyleVariableCategory, StyleVariableValue, TagType } from './StyleTypes';
+export type McpSpace = {
+    id: number;
+    name: string;
+    environments?: string[];
+};
+export type McpElement = {
+    id: string;
+    type: string;
+    label: string;
+    parentId?: string;
+    props?: Record<string, unknown>;
+    styles?: Record<string, unknown>;
+    runtime?: 'server' | 'client' | 'shared';
+    children?: string[];
+};
+export type McpSchema = {
+    spaceId: number;
+    environment: string;
+    revision: number;
+    elements: Record<string, McpElement>;
+};
+export type McpPlugin = {
+    name: string;
+    version?: string;
+    description?: string;
+};
+export type McpPage = {
+    id: string;
+    name: string;
+    isDefault: boolean;
+};
+export type McpStyleVariable = {
+    category: StyleVariableCategory;
+    name: string;
+    value: StyleVariableValue;
+};
+export type McpStyleSelector = {
+    displayMode: DisplayMode;
+    selector: string;
+    type: TagType;
+    path?: StyleCategory;
+    style?: StyleItem['attributes'];
+    params: Record<string, unknown>;
+};
+export type McpSegment = {
+    id?: string;
+    identifier: string;
+    definition: {
+        name: string;
+        description: string;
+        baseElementId: string;
+    };
+};
+export type McpAdapters = {
+    /** Return all spaces the agent may access. */
+    listSpaces: () => Promise<McpSpace[]>;
+    /** Return the full element tree for a space + environment. */
+    getSchema: (spaceId: number, environment: string) => Promise<McpSchema | undefined>;
+    /** Add a new element to the schema. Returns the created element with its generated ID. */
+    createElement: (spaceId: number, environment: string, element: {
+        type: string;
+        label: string;
+        props?: Record<string, unknown>;
+        runtime?: 'server' | 'client' | 'shared';
+    }, parentId?: string, position?: number) => Promise<McpElement>;
+    /** Update an existing element's label, props, styles, or runtime. */
+    updateElement: (spaceId: number, environment: string, elementId: string, updates: {
+        label?: string;
+        props?: Record<string, unknown>;
+        styles?: Record<string, unknown>;
+        runtime?: 'server' | 'client' | 'shared';
+    }) => Promise<McpElement>;
+    /** Remove an element and its descendants from the schema. */
+    deleteElement: (spaceId: number, environment: string, elementId: string) => Promise<void>;
+    /** Move an element to a different parent. */
+    moveElement: (spaceId: number, environment: string, elementId: string, toParentId: string, dropPosition?: DropPosition) => Promise<{
+        success: boolean;
+    }>;
+    /** Publish the current draft as a new revision. Returns the new revision number. */
+    publishSchema: (spaceId: number, environment: string) => Promise<{
+        revision: number;
+    }>;
+    /** Optional: list plugins registered in the system. */
+    listPlugins?: () => Promise<McpPlugin[]>;
+    /** Create a new page. */
+    createPage: (spaceId: number, environment: string, name: string) => Promise<McpPage>;
+    /** Delete a page by ID. */
+    deletePage: (spaceId: number, environment: string, pageId: string) => Promise<void>;
+    /** Create a new page folder. */
+    createPageFolder: (spaceId: number, environment: string, name: string, parentId?: string) => Promise<PageFolder>;
+    /** Update a page folder. */
+    updatePageFolder: (spaceId: number, environment: string, id: string, updates: Partial<Pick<PageFolder, 'name' | 'slug' | 'parentId'>>) => Promise<PageFolder>;
+    /** Delete a page folder. */
+    deletePageFolder: (spaceId: number, environment: string, id: string) => Promise<void>;
+    /** Create a schema variable. */
+    createVariable: (spaceId: number, environment: string, variable: Pick<SchemaVariable, 'name' | 'type' | 'value' | 'category'>) => Promise<SchemaVariable>;
+    /** Update a schema variable. */
+    updateVariable: (spaceId: number, environment: string, variable: Partial<SchemaVariable> & {
+        name: string;
+    }) => Promise<SchemaVariable>;
+    /** Delete a schema variable. */
+    deleteVariable: (spaceId: number, environment: string, name: string) => Promise<void>;
+    /** Create a global style variable. */
+    createStyleVariable: (spaceId: number, environment: string, category: StyleVariableCategory, name: string, value: StyleVariableValue) => Promise<McpStyleVariable>;
+    /** Update a global style variable. */
+    updateStyleVariable: (spaceId: number, environment: string, category: StyleVariableCategory, name: string, value: StyleVariableValue) => Promise<McpStyleVariable>;
+    /** Delete a global style variable. */
+    deleteStyleVariable: (spaceId: number, environment: string, category: StyleVariableCategory, name: string) => Promise<void>;
+    /** Create a global style selector. */
+    createStyleSelector: (spaceId: number, environment: string, displayMode: DisplayMode, selector: string, type: TagType, path?: StyleCategory, style?: StyleItem['attributes'], params?: Record<string, unknown>) => Promise<McpStyleSelector>;
+    /** Update a global style selector. */
+    updateStyleSelector: (spaceId: number, environment: string, displayMode: DisplayMode, selector: string, type: TagType, path?: StyleCategory, style?: StyleItem['attributes'], params?: Record<string, unknown>) => Promise<McpStyleSelector>;
+    /** Delete a global style selector. */
+    deleteStyleSelector: (spaceId: number, environment: string, displayMode: DisplayMode, selector: string) => Promise<void>;
+    /** Create a segment. */
+    createSegment: (spaceId: number, name: string, description: string) => Promise<McpSegment>;
+    /** Update a segment. */
+    updateSegment: (spaceId: number, segmentId: string, updates: {
+        name?: string;
+        description?: string;
+    }) => Promise<McpSegment>;
+    /** Delete a segment. */
+    deleteSegment: (spaceId: number, segmentId: string) => Promise<void>;
+    /** Add an element to a segment. */
+    createSegmentElement: (spaceId: number, segmentId: string, element: {
+        type: string;
+        label: string;
+        props?: Record<string, unknown>;
+    }, parentId: string) => Promise<McpElement>;
+    /** Update an element inside a segment. */
+    updateSegmentElement: (spaceId: number, segmentId: string, elementId: string, updates: {
+        label?: string;
+        props?: Record<string, unknown>;
+    }) => Promise<McpElement>;
+    /** Move an element inside a segment. */
+    moveSegmentElement: (spaceId: number, segmentId: string, elementId: string, toParentId: string, dropPosition?: DropPosition) => Promise<{
+        success: boolean;
+    }>;
+    /** Remove an element from a segment. */
+    deleteSegmentElement: (spaceId: number, segmentId: string, elementId: string) => Promise<void>;
+    /** Create a segment schema variable. */
+    createSegmentVariable: (spaceId: number, segmentId: string, variable: Pick<SchemaVariable, 'name' | 'type' | 'value' | 'category'>) => Promise<SchemaVariable>;
+    /** Update a segment schema variable. */
+    updateSegmentVariable: (spaceId: number, segmentId: string, variable: Partial<SchemaVariable> & {
+        name: string;
+    }) => Promise<SchemaVariable>;
+    /** Delete a segment schema variable. */
+    deleteSegmentVariable: (spaceId: number, segmentId: string, name: string) => Promise<void>;
+    /** Create a segment style variable. */
+    createSegmentStyleVariable: (spaceId: number, segmentId: string, category: StyleVariableCategory, name: string, value: StyleVariableValue) => Promise<McpStyleVariable>;
+    /** Update a segment style variable. */
+    updateSegmentStyleVariable: (spaceId: number, segmentId: string, category: StyleVariableCategory, name: string, value: StyleVariableValue) => Promise<McpStyleVariable>;
+    /** Delete a segment style variable. */
+    deleteSegmentStyleVariable: (spaceId: number, segmentId: string, category: StyleVariableCategory, name: string) => Promise<void>;
+};
+export type McpServerConfig = {
+    /** Whether the MCP endpoint is active. Defaults to true. */
+    enabled?: boolean;
+    /** URL path for the MCP endpoint. Defaults to '/mcp'. */
+    path?: string;
+    adapters: McpAdapters;
+};

package/dist/types/NavigationTypes.d.ts

@@ -0,0 +1,13 @@
+import { Helmet } from '@dr.pogodin/react-helmet';
+export type NavigationStatus = 'authenticated' | 'normal' | 'redirect' | 'notFound' | 'accessDenied';
+export type QueryParams = Record<string, string[] | string | undefined>;
+export type RouteParams = Record<string, string[] | string | undefined>;
+export type NavigationContextValue = {
+    Helmet?: typeof Helmet;
+    navigate: (url: string, isExternal?: boolean) => void;
+    urlSearchParams?: URLSearchParams;
+    routeParams: RouteParams;
+    queryParams: QueryParams;
+    hostname?: string;
+    currentPageId: string;
+};

package/dist/types/PluginTypes.d.ts

@@ -0,0 +1,121 @@
+import { ComponentDefinition } from './ElementTypes';
+import { Element } from './SchemaTypes';
+import { DisplayMode, StyleAttributes } from './StyleTypes';
+export type PluginSchema = {
+    attributes: Element['attributes'];
+    builder: PluginBuilder;
+    initialItems?: string[];
+    definition: Element['definition'];
+    defaultStyle: {
+        name: string;
+        displayMode: DisplayMode;
+        style: StyleAttributes;
+        subTypes?: Record<string, Omit<PluginSchema['defaultStyle'], 'subTypes'>>;
+        bindingsAllowed: {
+            attributes: {
+                path: string;
+                label: string;
+            }[];
+            initialState: {
+                path: string;
+                label: string;
+            }[];
+        };
+    };
+};
+export type ManifestAsset = {
+    integrity?: string;
+    src?: string;
+    srcPath?: string;
+    url?: string;
+    type: 'style' | 'script';
+    isMain?: boolean;
+};
+export type PluginManifest = {
+    assets: Record<string, ManifestAsset>;
+    assetsSettings: Record<string, ManifestAsset>;
+    author: string;
+    icon?: string;
+    definition: {
+        name: string;
+        backgroundColor: string;
+        category: string;
+        icon: string;
+        license: string;
+        owner: string;
+        verified: boolean;
+        website: string;
+    };
+    pluginSchema: Record<string, PluginSchema>;
+    root: string;
+    runtime: {
+        module: string;
+        scope: string;
+    };
+    created: string;
+    updated: string;
+    version: string;
+};
+export type PluginBuilder = {
+    canDelete?: boolean;
+    canDragDrop?: boolean;
+    canSelect?: boolean;
+    canMove?: boolean;
+    canTemplate?: boolean;
+    itemsAllowed?: string[];
+    itemsNotAllowed?: string[];
+};
+export type Asset = {
+    id: string;
+    type: 'link';
+    params: {
+        href: string;
+        type: 'text/css';
+        rel: 'stylesheet';
+    } & Record<string, string>;
+    isMain?: boolean;
+} | {
+    id: string;
+    type: 'script';
+    params: {
+        src: string;
+        type: 'text/javascript';
+    } & Record<string, string>;
+    isMain?: boolean;
+};
+export type Plugin = {
+    assets: Asset[];
+    assetsSettings: Omit<Asset, 'isMain'>[];
+    attributes: ComponentDefinition['attributes'];
+    builder: PluginBuilder;
+    defaultStyle: ComponentDefinition['defaultStyle'];
+    isMain?: boolean;
+    manifest: PluginManifest;
+    market: ComponentDefinition['market'];
+    module: string;
+    resource: string;
+    scope: string;
+    settings: Record<string, unknown>;
+    subPlugins?: string[];
+    type: string;
+};
+export type PluginsContextValue = {
+    baseAssets?: Record<string, Asset>;
+    assets: Record<string, Asset>;
+    plugins: Record<string, ComponentDefinition>;
+    dispatchPlugins?: unknown;
+    fetch?: (filter: object, cursor: string, limit: number) => Promise<unknown>;
+    add?: (pluginType: string, resource?: string) => Promise<boolean>;
+    setSettings?: (pluginType: string, attribute: string, value: string) => Promise<boolean>;
+    getSettings?: (pluginType: string, attribute?: string, defaultValue?: string | number | boolean) => ComponentDefinition['settings'] | string | number | boolean;
+    update?: (plugin: ComponentDefinition, resource?: string) => Promise<boolean>;
+    remove?: (pluginType: string) => Promise<boolean>;
+    registerCustomAssets: (assets: Asset[]) => void;
+    unregisterCustomAssets: (assets: string[]) => void;
+    pluginSettingsStyles?: Record<string, string[]>;
+};
+export type PluginRaw = {
+    resource: string;
+    settings: Plugin['settings'];
+    type: string;
+};

package/dist/types/ResourceTypes.d.ts

@@ -0,0 +1,40 @@
+import { PluginManifest } from './PluginTypes';
+import { SpaceCredential } from './SpaceTypes';
+export type ResourceType = 'image' | 'video' | 'document' | 'application' | 'plugin' | 'template';
+export type Resource = {
+    id: string;
+    cdnIdentifier: string;
+    name: string;
+    path: string;
+    type: Exclude<ResourceType, 'plugin'>;
+    size: number;
+} | {
+    id: string;
+    cdnIdentifier: string;
+    name: string;
+    path: string;
+    type: 'plugin';
+    size: number;
+    metadata: PluginManifest;
+};
+export type ResourceWithFile = Resource & {
+    file: File;
+};
+export type ResourceFile = File & {
+    id: number;
+    resourceType: ResourceType;
+    metadata?: PluginManifest;
+};
+export type Cdn = {
+    identifier: string;
+    name: string;
+    domain: string;
+    provider: 's3' | 'r2';
+    region: string;
+    endpoint?: string;
+    bucketName: string;
+    prefix: string;
+    credential?: SpaceCredential;
+    createdAt: number;
+    updatedAt: number;
+};