@plitzi/plitzi-builder 0.30.19

package/dist/modules/Marketplace/components/MarketTemplates/MarketTemplates.d.ts

@@ -0,0 +1,2 @@
+declare const MarketTemplates: () => import("react/jsx-runtime").JSX.Element;
+export default MarketTemplates;

package/dist/modules/Marketplace/components/MarketTemplates/index.d.ts

@@ -0,0 +1,3 @@
+import { default as MarketTemplates } from './MarketTemplates';
+export * from './MarketTemplates';
+export default MarketTemplates;

package/dist/modules/Marketplace/helpers/PluginHelper.d.ts

@@ -0,0 +1,2 @@
+import { MarketPlacePluginRaw, MarketPlacePlugin } from '../types';
+export declare const parsePlugin: (pluginRaw: MarketPlacePluginRaw) => MarketPlacePlugin;

package/dist/modules/Marketplace/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Marketplace } from './Marketplace';
+export * from './Marketplace';
+export default Marketplace;

package/dist/modules/Marketplace/types/index.d.ts

@@ -0,0 +1,44 @@
+export type MarketPlacePluginRaw = {
+    name: string;
+    description: string;
+    type: string;
+    latestVersion: {
+        version: string;
+        createdAt: number;
+        updatedAt: number;
+    };
+    version: string;
+    revisions: {
+        version: string;
+    }[];
+    market: {
+        icon: string;
+        backgroundColor: string;
+        owner: string;
+        category: {
+            name: string;
+        };
+        verified: boolean;
+        website: string;
+    };
+    createdAt: number;
+    updatedAt: number;
+};
+export type MarketPlacePlugin = {
+    name: string;
+    description: string;
+    type: string;
+    latestVersion: string;
+    version: string;
+    owner: string;
+    verified: boolean;
+    category: string;
+    color: string;
+    icon: string;
+    website: string;
+    revisions: {
+        version: string;
+    }[];
+    createdAt: number;
+    updatedAt: number;
+};

package/dist/modules/Navigation/NavigationContextProvider.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export type NavigationContextProviderProps = {
+    children?: ReactNode;
+    previewMode?: boolean;
+};
+declare const NavigationContextProvider: ({ previewMode, children }: NavigationContextProviderProps) => import("react/jsx-runtime").JSX.Element | "Not Found" | "Access Denied";
+export default NavigationContextProvider;

package/dist/modules/Network/NetworkContextProvider.d.ts

@@ -0,0 +1,13 @@
+import { Server, Environment } from '@plitzi/sdk-shared';
+import { ReactNode } from 'react';
+export type NetworkContextProviderProps = {
+    children: ReactNode;
+    webKey?: string;
+    webId: number;
+    userKey?: string;
+    instanceId: string;
+    server: Server;
+    environment?: Environment;
+};
+declare const NetworkContextProvider: ({ children, webKey, webId, userKey, instanceId, server, environment }: NetworkContextProviderProps) => import("react/jsx-runtime").JSX.Element | null;
+export default NetworkContextProvider;

package/dist/modules/Network/NetworkSubscriptionsContextProvider.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+export type NetworkSubscriptionsContextProviderProps = {
+    children: ReactNode;
+    includeSubscriptions?: boolean;
+    includeRealTime?: boolean;
+};
+declare const NetworkSubscriptionsContextProvider: ({ children, includeRealTime, includeSubscriptions }: NetworkSubscriptionsContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default NetworkSubscriptionsContextProvider;

package/dist/modules/Network/contexts/BuilderSubscriptionsContext.d.ts

@@ -0,0 +1,11 @@
+import { RTCallback, RTEvent, RTMessageManagedClient, SubscriptionCollaborator } from '@plitzi/sdk-shared';
+export type BuilderSubscriptionsContextValue = {
+    includeSubscriptions: boolean;
+    supportRealTime: boolean;
+    subscriptionsPush: (data: RTMessageManagedClient) => void;
+    subscriptionsRegisterCallback: (type: RTEvent, callback: RTCallback) => void;
+    subscriptionsUnregisterCallback: (type: RTEvent) => void;
+    subscriptionsCollaborators: SubscriptionCollaborator[];
+};
+declare const BuilderSubscriptionsContext: import('react').Context<BuilderSubscriptionsContextValue>;
+export default BuilderSubscriptionsContext;

package/dist/modules/Network/helpers/customFetch.d.ts

@@ -0,0 +1,12 @@
+type UploadOptions = {
+    onError?: (e: ProgressEvent) => void;
+    onProgress?: () => void;
+    onAbortPossible?: (callback: () => void) => void;
+    method?: string;
+    headers?: HeadersInit;
+    body?: BodyInit | null;
+    customFetch?: boolean;
+};
+export declare const uploadFetch: (url: URL | RequestInfo, options?: UploadOptions) => Promise<Response>;
+declare const customFetch: (uri: URL | RequestInfo, options?: UploadOptions) => Promise<Response>;
+export default customFetch;

package/dist/modules/Network/hooks/useGraphQL.d.ts

@@ -0,0 +1,15 @@
+import { BuilderQueriesMap } from '@plitzi/sdk-shared';
+import { KeyedMutator, SWRConfiguration } from 'swr';
+declare function useGraphQL<K extends keyof BuilderQueriesMap>(queryKey: K | null, transform?: undefined, variables?: Record<string, unknown>, config?: SWRConfiguration<BuilderQueriesMap[K]>): {
+    data: BuilderQueriesMap[K] | undefined;
+    error: Error | undefined;
+    isLoading: boolean;
+    mutate: KeyedMutator<BuilderQueriesMap[K]>;
+};
+declare function useGraphQL<K extends keyof BuilderQueriesMap, TK>(queryKey: K | null, transform: (data: BuilderQueriesMap[K] | undefined) => TK | undefined, variables?: Record<string, unknown>, config?: SWRConfiguration<BuilderQueriesMap[K]>): {
+    data: TK | undefined;
+    error: Error | undefined;
+    isLoading: boolean;
+    mutate: KeyedMutator<BuilderQueriesMap[K]>;
+};
+export default useGraphQL;

package/dist/modules/Network/hooks/useInfiniteGraphQL.d.ts

@@ -0,0 +1,18 @@
+import { BuilderQueriesMap, PageInfo } from '@plitzi/sdk-shared';
+import { SWRInfiniteConfiguration } from 'swr/infinite';
+declare const useInfiniteGraphQL: <K extends keyof BuilderQueriesMap, T>(queryKey: K | null, transform: (data: BuilderQueriesMap[K] | undefined) => {
+    edges: T[];
+    pageInfo: PageInfo;
+} | undefined, variables?: Record<string, unknown>, config?: SWRInfiniteConfiguration<BuilderQueriesMap[K]> & {
+    pageSize?: number;
+}) => {
+    data: (T | undefined)[];
+    error: Error | undefined;
+    size: number;
+    setSize: (size: number | ((_size: number) => number)) => Promise<BuilderQueriesMap[K][] | undefined>;
+    isLoading: boolean;
+    isValidating: boolean;
+    isEmpty: boolean;
+    mutate: import('swr/infinite').SWRInfiniteKeyedMutator<BuilderQueriesMap[K][]>;
+};
+export default useInfiniteGraphQL;

package/dist/modules/Network/hooks/useSubscriptionsManager.d.ts

@@ -0,0 +1,21 @@
+import { ApolloClient } from '@apollo/client/core';
+import { BuilderSubscriptionsMap } from '@plitzi/sdk-shared';
+import { ReactNode } from 'react';
+export type UseSubscriptionsManagerProps = {
+    onMessage?: (message: ReactNode, type?: 'info' | 'success' | 'warning' | 'error' | 'default') => void;
+    client: ApolloClient;
+    environment?: string;
+    disabled?: boolean;
+};
+type Subscription = {
+    closed: boolean;
+    unsubscribe(): void;
+    name: keyof BuilderSubscriptionsMap;
+};
+declare const useSubscriptionsManager: ({ onMessage, client, environment, disabled }: UseSubscriptionsManagerProps) => {
+    subscribe: <T extends keyof BuilderSubscriptionsMap>(subscriptionKey: T, variables: Record<string, unknown>, callback: (result: ApolloClient.SubscribeResult<BuilderSubscriptionsMap[T]>) => void) => false | import('@apollo/client').SubscriptionObservable<ApolloClient.SubscribeResult<BuilderSubscriptionsMap[T]>> | null;
+    unsubscribe: (subscriptionKey: keyof BuilderSubscriptionsMap | (keyof BuilderSubscriptionsMap)[]) => void;
+    stop: () => void;
+    subscriptions: import('react').RefObject<Subscription[]>;
+};
+export default useSubscriptionsManager;

package/dist/modules/Network/hooks/useWebsocket.d.ts

@@ -0,0 +1,20 @@
+import { RTEvent, RTMessageManagedClient } from '@plitzi/sdk-shared/websockets/RTCodec';
+export type UseWebsocketProps<T> = {
+    isBinary?: boolean;
+    url: string;
+    protocols?: string[];
+    processMessage: ((data: T) => void) | null;
+    initMessage?: {
+        type: RTEvent.INIT;
+        payload: undefined;
+    };
+    retryReconnect?: number;
+    connectMode?: 'auto' | 'manual';
+};
+declare const useWebsocket: <T = unknown>({ isBinary, url, protocols, processMessage, initMessage, retryReconnect, connectMode }: UseWebsocketProps<T>) => {
+    ws: WebSocket | undefined;
+    push: (data: RTMessageManagedClient) => void;
+    close: (closeCode?: number) => void;
+    connect: () => WebSocket | undefined;
+};
+export default useWebsocket;

package/dist/modules/OpenAI_Deprecated/OpenAIChat.d.ts

@@ -0,0 +1,2 @@
+declare const OpenAIChat: () => import("react/jsx-runtime").JSX.Element;
+export default OpenAIChat;

package/dist/modules/OpenAI_Deprecated/components/Chat/Chat.d.ts

@@ -0,0 +1,8 @@
+import { OpenAIMessage } from '../../types/openAI';
+import { RefObject } from 'react';
+export type ChatProps = {
+    ref?: RefObject<HTMLDivElement | null>;
+    messages?: OpenAIMessage[];
+};
+declare const Chat: ({ ref, messages }: ChatProps) => import("react/jsx-runtime").JSX.Element;
+export default Chat;

package/dist/modules/OpenAI_Deprecated/components/Chat/ChatMessage.d.ts

@@ -0,0 +1,8 @@
+import { OpenAIMessage, OpenAIRole } from '../../types/openAI';
+export type ChatMessageProps = {
+    id: string;
+    role: OpenAIRole;
+    content: OpenAIMessage['content'];
+};
+declare const ChatMessage: ({ id, role, content }: ChatMessageProps) => import("react/jsx-runtime").JSX.Element;
+export default ChatMessage;

package/dist/modules/OpenAI_Deprecated/components/Chat/Message/Message.d.ts

@@ -0,0 +1,9 @@
+import { OpenAIContentType } from '../../../types/openAI';
+export type MessageProps = {
+    message: {
+        type: OpenAIContentType;
+        content: string;
+    }[];
+};
+declare const Message: ({ message }: MessageProps) => import("react/jsx-runtime").JSX.Element;
+export default Message;

package/dist/modules/OpenAI_Deprecated/components/Chat/Message/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Message } from './Message';
+export * from './Message';
+export default Message;

package/dist/modules/OpenAI_Deprecated/components/Chat/Message/modes/MessageHtml.d.ts

@@ -0,0 +1,5 @@
+export type MessageHtmlProps = {
+    content?: string;
+};
+declare const MessageHtml: ({ content }: MessageHtmlProps) => import("react/jsx-runtime").JSX.Element;
+export default MessageHtml;

package/dist/modules/OpenAI_Deprecated/components/Chat/Message/modes/MessageText.d.ts

@@ -0,0 +1,7 @@
+export type MessageTextProps = {
+    content?: string;
+};
+declare const MessageText: ({ content }: {
+    content?: string | undefined;
+}) => import("react/jsx-runtime").JSX.Element;
+export default MessageText;

package/dist/modules/OpenAI_Deprecated/components/Chat/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Chat } from './Chat';
+export * from './Chat';
+export default Chat;

package/dist/modules/OpenAI_Deprecated/components/VoiceVisualizer/VoiceVisualizer.d.ts

@@ -0,0 +1,18 @@
+import { RefObject } from 'react';
+export type VoiceVisualizerProps = {
+    className?: string;
+    audioData?: Uint8Array<ArrayBuffer>;
+    recordingPaused?: boolean;
+    isRecording?: boolean;
+    speed?: number;
+    backgroundColor?: string;
+    mainBarColor?: string;
+    barWidth?: number;
+    gap?: number;
+    rounded?: number;
+    animateCurrentPick?: boolean;
+    fullscreen?: boolean;
+    ref?: RefObject<HTMLCanvasElement | null>;
+};
+declare const VoiceVisualizer: ({ ref, className, audioData, recordingPaused, isRecording, speed, backgroundColor, mainBarColor, barWidth, gap, rounded, animateCurrentPick, fullscreen }: VoiceVisualizerProps) => import("react/jsx-runtime").JSX.Element;
+export default VoiceVisualizer;

package/dist/modules/OpenAI_Deprecated/components/VoiceVisualizer/helpers/drawByBlob.d.ts

@@ -0,0 +1,11 @@
+export declare const drawByBlob: ({ barsData, canvas, barWidth, gap, backgroundColor, mainBarColor, rounded }: {
+    barsData: {
+        max: number;
+    }[];
+    canvas: HTMLCanvasElement;
+    barWidth: number;
+    gap: number;
+    backgroundColor: string;
+    mainBarColor: string;
+    rounded: number;
+}) => void;

package/dist/modules/OpenAI_Deprecated/components/VoiceVisualizer/helpers/drawByLiveStream.d.ts

@@ -0,0 +1,20 @@
+import { RefObject } from 'react';
+export declare const drawByLiveStream: ({ audioData, unit, index, index2, canvas, isRecording, isPausedRecording, picks, backgroundColor, barWidth, mainBarColor, rounded, animateCurrentPick, fullscreen }: {
+    audioData?: Uint8Array<ArrayBuffer>;
+    unit: number;
+    index: RefObject<number>;
+    index2: RefObject<number>;
+    canvas: HTMLCanvasElement;
+    isRecording: boolean;
+    isPausedRecording: boolean;
+    picks: ({
+        startY: number;
+        barHeight: number;
+    } | null)[];
+    backgroundColor: string;
+    barWidth: number;
+    mainBarColor: string;
+    rounded: number;
+    animateCurrentPick: boolean;
+    fullscreen: boolean;
+}) => void;

package/dist/modules/OpenAI_Deprecated/components/VoiceVisualizer/helpers/getBarsData.d.ts

@@ -0,0 +1,9 @@
+export declare const getBarsData: ({ bufferData, height, width, barWidth, gap }: {
+    bufferData: number[];
+    height: number;
+    width: number;
+    barWidth: number;
+    gap: number;
+}) => {
+    max: number;
+}[];

package/dist/modules/OpenAI_Deprecated/components/VoiceVisualizer/helpers/index.d.ts

@@ -0,0 +1,7 @@
+import { drawByBlob } from './drawByBlob';
+import { drawByLiveStream } from './drawByLiveStream';
+import { getBarsData } from './getBarsData';
+import { initialCanvasSetup } from './initialCanvasSetup';
+import { paintLine } from './paintLine';
+import { paintLineFromCenterToRight } from './paintLineFromCenterToRight';
+export { paintLine, drawByBlob, initialCanvasSetup, drawByLiveStream, paintLineFromCenterToRight, getBarsData };

package/dist/modules/OpenAI_Deprecated/components/VoiceVisualizer/helpers/initialCanvasSetup.d.ts

@@ -0,0 +1,9 @@
+export declare const initialCanvasSetup: ({ canvas, backgroundColor }: {
+    canvas: HTMLCanvasElement;
+    backgroundColor: string;
+}) => {
+    context: CanvasRenderingContext2D;
+    height: number;
+    width: number;
+    halfWidth: number;
+} | null;

package/dist/modules/OpenAI_Deprecated/components/VoiceVisualizer/helpers/paintLine.d.ts

@@ -0,0 +1,9 @@
+export declare const paintLine: ({ context, color, rounded, x, y, w, h }: {
+    context: CanvasRenderingContext2D;
+    color: string;
+    rounded: number;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}) => void;

package/dist/modules/OpenAI_Deprecated/components/VoiceVisualizer/helpers/paintLineFromCenterToRight.d.ts

@@ -0,0 +1,8 @@
+export declare function paintLineFromCenterToRight({ context, color, rounded, width, height, barWidth }: {
+    context: CanvasRenderingContext2D;
+    color: string;
+    rounded: number;
+    width: number;
+    height: number;
+    barWidth: number;
+}): void;

package/dist/modules/OpenAI_Deprecated/components/VoiceVisualizer/index.d.ts

@@ -0,0 +1,3 @@
+import { default as VoiceVisualizer } from './VoiceVisualizer';
+export * from './VoiceVisualizer';
+export default VoiceVisualizer;

package/dist/modules/OpenAI_Deprecated/hooks/useMediaRecorder.d.ts

@@ -0,0 +1,18 @@
+export type UseMediaRecorderProps = {
+    mimeType?: string;
+    onPausedRecording?: () => void;
+    onResumedRecording?: () => void;
+    onUpdate?: (chunks: Blob[], chunk: Blob) => void;
+    onFinish?: (audioUrl: string, audioBlob: Blob) => void | Promise<void>;
+};
+declare const useMediaRecorder: ({ mimeType, onPausedRecording, onResumedRecording, onUpdate, onFinish }: UseMediaRecorderProps) => {
+    start: () => Promise<void>;
+    resume: () => void;
+    pause: () => void;
+    stop: () => void;
+    recording: boolean;
+    error: string | undefined;
+    audioData: Uint8Array<ArrayBuffer>;
+    paused: boolean;
+};
+export default useMediaRecorder;

package/dist/modules/OpenAI_Deprecated/hooks/useWebWorker.d.ts

@@ -0,0 +1,10 @@
+export type UseWebWorkerProps = {
+    fn?: (data: unknown) => unknown;
+    initialValue?: unknown;
+    onMessageReceived?: () => void;
+};
+export declare function useWebWorker({ fn, initialValue, onMessageReceived }: UseWebWorkerProps): {
+    result: unknown;
+    setResult: import('react').Dispatch<unknown>;
+    run: (value: unknown) => void;
+};

package/dist/modules/OpenAI_Deprecated/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/OpenAI_Deprecated/types/openAI.d.ts

@@ -0,0 +1,20 @@
+export type OpenAIRole = 'user' | 'assistant';
+export type OpenAIContentType = 'text' | 'html';
+export type OpenAIMessage = {
+    assistant_id?: string | null;
+    attachments: unknown[];
+    content: {
+        text: {
+            value: string;
+            annotations?: unknown[];
+        };
+        type: OpenAIContentType;
+    }[];
+    created_at: number;
+    id: string;
+    metadata: object;
+    object: string;
+    role: OpenAIRole;
+    run_id?: string | null;
+    thread_id?: string | null;
+};

package/dist/modules/Plugins/PluginsContextProvider.d.ts

@@ -0,0 +1,8 @@
+import { ComponentDefinition } from '@plitzi/sdk-shared';
+import { ReactNode } from 'react';
+export type PluginsContextProviderProps = {
+    children?: ReactNode;
+    plugins?: Record<string, ComponentDefinition>;
+};
+declare const PluginsContextProvider: ({ children, plugins: pluginsProp }: PluginsContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default PluginsContextProvider;

package/dist/modules/Plugins/PluginsReducer.d.ts

@@ -0,0 +1,25 @@
+import { ComponentDefinition } from '@plitzi/sdk-shared';
+export type PluginsReducerActions = {
+    type: 'init';
+    plugins: Record<string, ComponentDefinition>;
+} | {
+    type: 'add';
+    plugin: ComponentDefinition;
+} | {
+    type: 'addMany';
+    plugins: Record<string, ComponentDefinition>;
+} | {
+    type: 'update';
+    plugin: ComponentDefinition;
+} | {
+    type: 'updateMany';
+    plugins: Record<string, ComponentDefinition>;
+} | {
+    type: 'remove';
+    pluginType: string;
+} | {
+    type: 'removeMany';
+    pluginTypes: string[];
+};
+declare const PluginsReducer: (state: Record<string, ComponentDefinition>, action: PluginsReducerActions) => Record<string, ComponentDefinition>;
+export default PluginsReducer;

package/dist/modules/Plugins/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/Queue/QueueContext.d.ts

@@ -0,0 +1,25 @@
+import { ReducerMiddlewareCallback } from '@plitzi/plitzi-ui/hooks/useReducerWithMiddleware';
+import { SchemaReducerActions } from '@plitzi/sdk-schema/SchemaReducer';
+import { Schema, Segment, Style } from '@plitzi/sdk-shared';
+import { StyleReducerActions } from '@plitzi/sdk-style/StyleReducer';
+import { SegmentsReducerActions } from '../Segments/SegmentsReducer';
+import { ActionDispatch } from 'react';
+export type QueueItem<TState = any, TDispatchAction = any> = {
+    action: TDispatchAction;
+    prevState: TState;
+    state: TState;
+    dispatch: ActionDispatch<[action: TDispatchAction]>;
+};
+export type QueuePriority = 'normal' | 'urgent' | 'all';
+export type QueueContextValue = {
+    queueManager: {
+        count: (priority?: QueuePriority) => number;
+        enqueue: (items?: QueueItem | QueueItem[], priority?: QueuePriority) => void;
+        getIsProcessing: () => boolean;
+    };
+    enqueueMiddleware: ReducerMiddlewareCallback<Schema | Style | Record<string, Segment>, [
+        action: StyleReducerActions | SchemaReducerActions | SegmentsReducerActions
+    ]>;
+};
+declare const QueueContext: import('react').Context<QueueContextValue>;
+export default QueueContext;

package/dist/modules/Queue/QueueContextProvider.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export type QueueContextProviderProps = {
+    children: ReactNode;
+    includeSubscriptions?: boolean;
+};
+declare const QueueContextProvider: ({ children, includeSubscriptions }: QueueContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+export default QueueContextProvider;

package/dist/modules/Queue/QueueStatusContext.d.ts

@@ -0,0 +1,3 @@
+export type QueueStatusContextValue = boolean;
+declare const QueueStatusContext: import('react').Context<boolean>;
+export default QueueStatusContext;

package/dist/modules/Queue/hooks/useQueueManager.d.ts

@@ -0,0 +1,19 @@
+import { QueueItem, QueuePriority } from '../QueueContext';
+import { BuilderMutationsMap, BuilderQueriesMap } from '@plitzi/sdk-shared';
+import { NetworkContextValue } from '@plitzi/sdk-shared/network/NetworkContext';
+export type UseQueueManagerProps = {
+    delay?: number;
+    mutate: NetworkContextValue<BuilderQueriesMap, BuilderMutationsMap>['mutate'];
+    maxRetries?: number;
+    retryTimeout?: number;
+    disabled?: boolean;
+};
+declare const useQueueManager: ({ delay, mutate, maxRetries, retryTimeout, disabled }: UseQueueManagerProps) => {
+    queueManager: {
+        count: (priority?: QueuePriority) => number;
+        enqueue: (items?: QueueItem | QueueItem[], priority?: QueuePriority) => void;
+        getIsProcessing: () => boolean;
+    };
+    processing: boolean;
+};
+export default useQueueManager;

package/dist/modules/Resources/Models/PluginSettingsForm.d.ts

@@ -0,0 +1,8 @@
+export type PluginSettingsFormProps = {
+    className?: string;
+    values?: object;
+    onClose?: () => void;
+    onSubmit?: (values: object) => void;
+};
+declare const PluginSettingsForm: ({ className }: PluginSettingsFormProps) => import("react/jsx-runtime").JSX.Element;
+export default PluginSettingsForm;

package/dist/modules/Resources/Models/ResourceCdnForm.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { MouseEvent } from 'react';
+declare const resourceCdnFormSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    provider: z.ZodLiteral<"s3">;
+    name: z.ZodString;
+    domain: z.ZodString;
+    region: z.ZodString;
+    endpoint: z.ZodOptional<z.ZodString>;
+    bucketName: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    provider: z.ZodLiteral<"r2">;
+    name: z.ZodString;
+    domain: z.ZodString;
+    region: z.ZodDefault<z.ZodString>;
+    endpoint: z.ZodString;
+    bucketName: z.ZodString;
+}, z.core.$strip>], "provider">;
+export type ResourceCdnFormProps = {
+    className?: string;
+    name?: string;
+    domain?: string;
+    provider?: 's3' | 'r2';
+    region?: string;
+    endpoint?: string;
+    bucketName?: string;
+    onClose?: (e?: MouseEvent) => void;
+    onSubmit?: (e: MouseEvent | undefined, values: z.infer<typeof resourceCdnFormSchema>) => void;
+};
+declare const ResourceCdnForm: ({ name, domain, provider, region, endpoint, bucketName, onSubmit, onClose }: ResourceCdnFormProps) => import("react/jsx-runtime").JSX.Element;
+export default ResourceCdnForm;

package/dist/modules/Resources/Models/ResourceDirectoryForm.d.ts

@@ -0,0 +1,15 @@
+import { MouseEvent } from 'react';
+export type ResourceDirectoryFormProps = {
+    className?: string;
+    name?: string;
+    directories?: {
+        name: string;
+        items: unknown[];
+    }[];
+    onClose?: (e?: MouseEvent) => void;
+    onSubmit?: (e: MouseEvent | undefined, values: {
+        name: string;
+    }) => void;
+};
+declare const ResourceDirectoryForm: ({ name, directories, onSubmit, onClose }: ResourceDirectoryFormProps) => import("react/jsx-runtime").JSX.Element;
+export default ResourceDirectoryForm;

package/dist/modules/Resources/Resources.d.ts

@@ -0,0 +1,2 @@
+declare const Resources: () => import("react/jsx-runtime").JSX.Element;
+export default Resources;

package/dist/modules/Resources/components/Resource/Resource.d.ts

@@ -0,0 +1,15 @@
+import { PluginManifest, ResourceType as TResourceType } from '@plitzi/sdk-shared';
+export type ResourceProps = {
+    className?: string;
+    id: string;
+    cdnIdentifier: string;
+    type?: TResourceType;
+    src?: string;
+    title?: string;
+    metadata?: PluginManifest;
+    directoryName?: string;
+    isLoading?: boolean;
+    onRemove?: (id: string) => void;
+};
+declare const Resource: ({ className, id, cdnIdentifier, type, src, title, metadata, directoryName, isLoading, onRemove }: ResourceProps) => import("react/jsx-runtime").JSX.Element;
+export default Resource;

package/dist/modules/Resources/components/Resource/ResourceLoading.d.ts

@@ -0,0 +1,2 @@
+declare const ResourceLoading: () => import("react/jsx-runtime").JSX.Element;
+export default ResourceLoading;

package/dist/modules/Resources/components/Resource/ResourceName.d.ts

@@ -0,0 +1,6 @@
+export type ResourceNameProps = {
+    name?: string;
+    fullWidth?: boolean;
+};
+declare const ResourceName: ({ name }: ResourceNameProps) => import("react/jsx-runtime").JSX.Element;
+export default ResourceName;

package/dist/modules/Resources/components/Resource/ResourceRemoveButton.d.ts

@@ -0,0 +1,6 @@
+import { MouseEvent } from 'react';
+export type ResourceRemoveButtonProps = {
+    onRemove?: (e: MouseEvent) => void;
+};
+declare const ResourceRemoveButton: ({ onRemove }: ResourceRemoveButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default ResourceRemoveButton;

package/dist/modules/Resources/components/Resource/index.d.ts

@@ -0,0 +1,3 @@
+import { default as Resource } from './Resource';
+export * from './Resource';
+export default Resource;