@aws-amplify/ui-react-storage 0.0.0-studio-console-80bb2e2-20230921222703 → 0.0.0-testdelay-84839eb-20250107181059

package/dist/types/components/StorageBrowser/providers/configuration/credentials/useCredentialsStore.d.ts

@@ -0,0 +1,8 @@
+import { CredentialsStore, RegisterAuthListener } from './types';
+import { GetLocationCredentials } from '../../../credentials/types';
+export declare function useCredentialsStore({ getLocationCredentials: handler, initialValue, onDestroy, registerAuthListener, }: {
+    getLocationCredentials: GetLocationCredentials;
+    initialValue?: CredentialsStore;
+    onDestroy?: () => void;
+    registerAuthListener: RegisterAuthListener;
+}): CredentialsStore;

package/dist/types/components/StorageBrowser/providers/configuration/index.d.ts

@@ -0,0 +1,4 @@
+export { createConfigurationProvider } from './createConfigurationProvider';
+export { useGetActionInput } from './context';
+export { CredentialsProviderProps, RegisterAuthListener } from './credentials';
+export { GetActionInput } from './types';

package/dist/types/components/StorageBrowser/providers/configuration/types.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { ActionInputConfig, LocationData } from '../../actions';
+import { CredentialsProviderProps } from './credentials';
+export type GetActionInput = (location?: LocationData) => ActionInputConfig;
+export interface GetActionInputProviderProps {
+    accountId?: string;
+    children?: React.ReactNode;
+    region: string;
+    customEndpoint?: string;
+}
+export interface CreateConfigurationProviderInput<T extends React.ComponentType<any>> extends GetActionInputProviderProps, CredentialsProviderProps {
+    ChildComponent?: T;
+    displayName: string;
+    region: string;
+}
+export interface ConfigurationProviderComponent<T extends React.ComponentType<any>> {
+    (props: React.ComponentProps<T>): React.JSX.Element;
+    displayName: string;
+}

package/dist/types/components/StorageBrowser/providers/configuration/useGetActionInputCallback.d.ts

@@ -0,0 +1,7 @@
+import { GetActionInput } from './types';
+export declare const getErrorMessage: (propertyName: string) => string;
+export declare function useGetActionInputCallback({ accountId, customEndpoint, region, }: {
+    accountId?: string;
+    customEndpoint?: string;
+    region: string;
+}): GetActionInput;

package/dist/types/components/StorageBrowser/providers/index.d.ts

@@ -0,0 +1,2 @@
+export { createConfigurationProvider, CredentialsProviderProps, RegisterAuthListener, } from './configuration';
+export { FileItem, FileItems, StoreProviderProps, StoreProvider, } from './store';

package/dist/types/components/StorageBrowser/providers/store/StoreProvider.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { LocationProviderProps } from './location';
+import { FilesProviderProps } from './files';
+import { ActionTypeProviderProps } from './actionType';
+import { LocationItemsProviderProps } from './locationItems';
+export interface StoreProviderProps extends ActionTypeProviderProps, FilesProviderProps, LocationProviderProps, LocationItemsProviderProps {
+}
+export declare function StoreProvider(props: StoreProviderProps): React.JSX.Element;

package/dist/types/components/StorageBrowser/providers/store/actionType/context.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { ActionTypeProviderProps, ActionTypeStateContext } from './types';
+export declare const ActionTypeContext: React.Context<ActionTypeStateContext>, useActionType: (params?: {
+    errorMessage?: string | undefined;
+} | undefined) => ActionTypeStateContext;
+export declare function ActionTypeProvider({ actionType, children, }: ActionTypeProviderProps): React.JSX.Element;

package/dist/types/components/StorageBrowser/providers/store/actionType/index.d.ts

@@ -0,0 +1,2 @@
+export { ActionTypeProvider, useActionType } from './context';
+export * from './types';

package/dist/types/components/StorageBrowser/providers/store/actionType/types.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+export type ActionTypeAction = {
+    type: 'SET_ACTION_TYPE';
+    actionType: string;
+} | {
+    type: 'RESET_ACTION_TYPE';
+};
+export type HandleActionTypeAction = (event: ActionTypeAction) => void;
+export type ActionTypeStateContext = [
+    string | undefined,
+    HandleActionTypeAction
+];
+export interface ActionTypeProviderProps {
+    actionType?: string;
+    children?: React.ReactNode;
+}

package/dist/types/components/StorageBrowser/providers/store/actionType/useActionTypeState.d.ts

@@ -0,0 +1,2 @@
+import { ActionTypeStateContext } from './types';
+export declare function useActionTypeState(initialState?: string): ActionTypeStateContext;

package/dist/types/components/StorageBrowser/providers/store/files/context.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { FilesContextType, FilesProviderProps } from './types';
+export declare const FilesContext: React.Context<FilesContextType>, useFiles: (params?: {
+    errorMessage?: string | undefined;
+} | undefined) => FilesContextType;
+export declare function FilesProvider({ children, }: FilesProviderProps): React.JSX.Element;

package/dist/types/components/StorageBrowser/providers/store/files/index.d.ts

@@ -0,0 +1,2 @@
+export { FilesProvider, FilesContext, useFiles } from './context';
+export * from './types';

package/dist/types/components/StorageBrowser/providers/store/files/types.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="react" />
+import { LocationItemType, TaskData } from '../../../actions';
+/**
+ * native OS file picker type. to restrict selectable file types, define the picker types
+ * followed by accepted file types as strings
+ * @example
+ * ```ts
+ * type JPEGOnly = ['FOLDER', '.jpeg'];
+ * ```
+ */
+export type SelectionType = LocationItemType | [LocationItemType, ...string[]];
+export type FilesActionType = {
+    type: 'ADD_FILE_ITEMS';
+    files?: File[];
+} | {
+    type: 'REMOVE_FILE_ITEM';
+    id: string;
+} | {
+    type: 'SELECT_FILES';
+    selectionType?: SelectionType;
+} | {
+    type: 'RESET_FILE_ITEMS';
+};
+export type HandleFilesAction = (input: FilesActionType) => void;
+export interface FileItem extends TaskData {
+    file: File;
+}
+export type FileItems = FileItem[];
+export type FilesContextType = [FileItems | undefined, HandleFilesAction];
+export interface FilesProviderProps {
+    children?: React.ReactNode;
+}

package/dist/types/components/StorageBrowser/providers/store/files/utils.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { FileItems, FilesActionType, SelectionType } from './types';
+export declare const resolveFiles: (prevItems: FileItems, files: File[] | undefined) => FileItems;
+export declare const filesReducer: React.Reducer<FileItems, Exclude<FilesActionType, {
+    type: 'SELECT_FILES';
+}>>;
+export declare const parseFileSelectParams: (value?: SelectionType) => [selectType: import("@aws-amplify/ui-react/dist/types/components/FileSelect/FileSelect").SelectType, options?: import("@aws-amplify/ui-react/internal").FileSelectOptions | undefined];

package/dist/types/components/StorageBrowser/providers/store/index.d.ts

@@ -0,0 +1,3 @@
+export { FileItem, FileItems } from './files';
+export { StoreProvider, StoreProviderProps } from './StoreProvider';
+export { useStore, UseStoreState } from './useStore';

package/dist/types/components/StorageBrowser/providers/store/location/context.d.ts

@@ -0,0 +1,58 @@
+import React from 'react';
+import { LocationData } from '../../../actions';
+export declare const ERROR_MESSAGE = "Invalid `location` value provided as initial value to `LocationProvider.";
+export declare const DEFAULT_STATE: LocationState;
+export type LocationActionType = {
+    type: 'NAVIGATE';
+    location: LocationData;
+    path?: string;
+} | {
+    type: 'RESET_LOCATION';
+};
+/**
+ * Stores current `location` and nested `path` values set on
+ * navigate events.
+ *
+ * @example
+ *`"s3://my-bucket/my/prefix/a-path/a-nested-path/"`
+ *
+ * ```
+ * const state: LocationState = {
+ *   location: {
+ *     bucket: 'my-bucket',
+ *     permisson: 'READWRITE',
+ *     prefix: 'my/prefix/',
+ *     type: 'PREFIX',
+ *   },
+ *   path: 'a-path/a-nested-path/',
+ *   key: 'my/prefix/a-path/a-nested-path/',
+ * }
+ *
+ */
+export interface LocationState {
+    /**
+     * current `location` metadata
+     */
+    current: LocationData | undefined;
+    /**
+     * current `location` subpath within a `location`
+     */
+    path: string;
+    /**
+     * fully qualified string consisting of `location` prefix and path
+     */
+    key: string;
+}
+export type LocationStateContext = [
+    LocationState,
+    (action: LocationActionType) => void
+];
+export interface LocationProviderProps {
+    children?: React.ReactNode;
+    location?: LocationData;
+    path?: string;
+}
+export declare const LocationContext: React.Context<LocationStateContext>, useLocation: (params?: {
+    errorMessage?: string | undefined;
+} | undefined) => LocationStateContext;
+export declare function LocationProvider({ children, location, path, }: LocationProviderProps): React.JSX.Element;

package/dist/types/components/StorageBrowser/providers/store/location/index.d.ts

@@ -0,0 +1 @@
+export { LocationActionType, LocationProviderProps, LocationState, LocationProvider, useLocation, } from './context';

package/dist/types/components/StorageBrowser/providers/store/locationItems/context.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { FileData, FileDataItem } from '../../../actions';
+export declare const DEFAULT_STATE: LocationItemsState;
+export type LocationItemsAction = {
+    type: 'SET_LOCATION_ITEMS';
+    items?: FileData[];
+} | {
+    type: 'REMOVE_LOCATION_ITEM';
+    id: string;
+} | {
+    type: 'RESET_LOCATION_ITEMS';
+};
+export interface LocationItemsState {
+    fileDataItems: FileDataItem[] | undefined;
+}
+export type HandleLocationItemsAction = (event: LocationItemsAction) => void;
+export type LocationItemStateContext = [
+    LocationItemsState,
+    HandleLocationItemsAction
+];
+export interface LocationItemsProviderProps {
+    children?: React.ReactNode;
+}
+export declare const LocationItemsContext: React.Context<LocationItemStateContext>, useLocationItems: (params?: {
+    errorMessage?: string | undefined;
+} | undefined) => LocationItemStateContext;
+export declare function LocationItemsProvider({ children, }: LocationItemsProviderProps): React.JSX.Element;

package/dist/types/components/StorageBrowser/providers/store/locationItems/index.d.ts

@@ -0,0 +1 @@
+export { LocationItemsAction, LocationItemsProvider, LocationItemsProviderProps, LocationItemsState, useLocationItems, } from './context';

package/dist/types/components/StorageBrowser/providers/store/useStore.d.ts

@@ -0,0 +1,12 @@
+import { ActionTypeAction } from './actionType';
+import { FileItems, FilesActionType } from './files';
+import { LocationActionType, LocationState } from './location';
+import { LocationItemsAction, LocationItemsState } from './locationItems';
+export interface UseStoreState {
+    actionType: string | undefined;
+    files: FileItems | undefined;
+    location: LocationState;
+    locationItems: LocationItemsState;
+}
+export type HandleStoreAction = (action: ActionTypeAction | FilesActionType | LocationActionType | LocationItemsAction) => void;
+export declare function useStore(): [UseStoreState, HandleStoreAction];

package/dist/types/components/StorageBrowser/storage-internal.d.ts

@@ -0,0 +1 @@
+export { AWSTemporaryCredentials, CopyInput, CredentialsLocation, CredentialsProvider, GetUrlInput, ListLocations, ListLocationsOutput, ListOutput, ListPaginateInput, LocationAccess, LocationCredentials, LocationCredentialsProvider, Permission, RemoveInput, StorageAccess, StorageSubpathStrategy, StorageValidationErrorCode, UploadDataInput, ListPathsOutput, assertValidationError, copy, getDataAccess, getUrl, list, listCallerAccessGrants, listPaths, remove, uploadData, validationErrorMap, } from '@aws-amplify/storage/internals';

package/dist/types/components/StorageBrowser/tasks/constants.d.ts

@@ -0,0 +1,2 @@
+import { StatusCounts } from './types';
+export declare const INITIAL_STATUS_COUNTS: StatusCounts;

package/dist/types/components/StorageBrowser/tasks/index.d.ts

@@ -0,0 +1,3 @@
+export { INITIAL_STATUS_COUNTS } from './constants';
+export { useProcessTasks } from './useProcessTasks';
+export { StatusCounts, Task, Tasks, TaskStatus } from './types';

package/dist/types/components/StorageBrowser/tasks/types.d.ts

@@ -0,0 +1,33 @@
+import { TaskHandlerInput, TaskData } from '../actions';
+export type TaskStatus = 'CANCELED' | 'FAILED' | 'COMPLETE' | 'OVERWRITE_PREVENTED' | 'QUEUED' | 'PENDING';
+export type StatusCounts = Record<TaskStatus | 'TOTAL', number>;
+export interface ProcessTasksOptions<T extends TaskData = TaskData, V = any, U extends number | never = never> {
+    concurrency?: U;
+    onTaskCancel?: (data: Task<T>) => void;
+    onTaskComplete?: (data: Task<T>) => void;
+    onTaskError?: (data: Task<T>, error: Error | undefined) => void;
+    onTaskProgress?: (data: Task<T>, progress: number | undefined) => void;
+    onTaskSuccess?: (data: Task<T>, value: V | undefined) => void;
+    onTaskRemove?: (data: Task<T>) => void;
+}
+export interface Task<T extends TaskData = TaskData, V = any> {
+    data: T;
+    message: string | undefined;
+    progress: number | undefined;
+    status: TaskStatus;
+    cancel?: () => void;
+    value?: V;
+}
+export type Tasks<T extends TaskData, V = any> = Task<T, V>[];
+export type HandleProcessTasks<T extends TaskData, U> = (input: U extends T[] ? Omit<TaskHandlerInput<T>, 'data'> : TaskHandlerInput<T>) => void;
+export interface TasksState<T extends TaskData = TaskData> {
+    isProcessing: boolean;
+    isProcessingComplete: boolean;
+    reset: () => void;
+    statusCounts: StatusCounts;
+    tasks: Tasks<T>;
+}
+export type UseProcessTasksState<T extends TaskData, D> = [
+    TasksState<T>,
+    HandleProcessTasks<T, D>
+];

package/dist/types/components/StorageBrowser/tasks/useProcessTasks.d.ts

@@ -0,0 +1,3 @@
+import { ActionHandler, TaskData } from '../actions';
+import { ProcessTasksOptions, UseProcessTasksState } from './types';
+export declare const useProcessTasks: <TData extends TaskData = TaskData, RValue = any, D extends TData[] | undefined = undefined>(handler: ActionHandler<TData, RValue>, items?: D | undefined, options?: ProcessTasksOptions<TData, RValue, D extends TData[] ? number : never> | undefined) => UseProcessTasksState<TData, D>;

package/dist/types/components/StorageBrowser/tasks/utils.d.ts

@@ -0,0 +1,4 @@
+import { StatusCounts, Task } from './types';
+export declare const getStatusCounts: (tasks?: Task[]) => StatusCounts;
+export declare const isProcessingTasks: (statusCounts: StatusCounts) => boolean;
+export declare const hasCompletedProcessingTasks: (statusCounts: StatusCounts) => boolean;

package/dist/types/components/StorageBrowser/types.d.ts

@@ -0,0 +1,69 @@
+import React from 'react';
+import { CustomActionConfigs, DefaultActionConfigs, ExtendedActionConfigs, ListLocations } from './actions';
+import { GetLocationCredentials } from './credentials/types';
+import { UseView } from './views/useView';
+import { Components } from './ComponentsProvider';
+import { RegisterAuthListener, StoreProviderProps } from './providers';
+import { CopyViewType, CreateFolderViewType, DeleteViewType, UploadViewType, LocationActionViewType, LocationDetailViewType, LocationsViewType, Views } from './views';
+import { StorageBrowserDisplayText } from './displayText';
+import { DerivedActionHandlers, UseAction } from './useAction';
+export interface Config {
+    accountId?: string;
+    customEndpoint?: string;
+    getLocationCredentials: GetLocationCredentials;
+    listLocations: ListLocations;
+    registerAuthListener: RegisterAuthListener;
+    region: string;
+}
+export interface StorageBrowserActions {
+    default?: DefaultActionConfigs;
+    custom?: CustomActionConfigs;
+}
+export interface CreateStorageBrowserInput {
+    actions?: StorageBrowserActions;
+    config: Config;
+    components?: Components;
+}
+export interface StorageBrowserProps<K = string, V = {}> {
+    displayText?: StorageBrowserDisplayText;
+    views?: Views<K, V>;
+}
+export interface StorageBrowserProviderProps<V = {}> extends StoreProviderProps {
+    displayText?: StorageBrowserDisplayText;
+    views?: V;
+}
+export interface StorageBrowserType<K = string, V = {}> {
+    (props: StorageBrowserProps<K, V>): React.JSX.Element;
+    displayName: string;
+    Provider: (props: StorageBrowserProviderProps<V>) => React.JSX.Element;
+    CopyView: CopyViewType;
+    CreateFolderView: CreateFolderViewType;
+    DeleteView: DeleteViewType;
+    UploadView: UploadViewType;
+    LocationActionView: LocationActionViewType<K>;
+    LocationDetailView: LocationDetailViewType;
+    LocationsView: LocationsViewType;
+}
+type DefaultActionType<T = string> = Exclude<T, keyof DefaultActionConfigs>;
+/**
+ * @internal @unstable
+ */
+export type DerivedActionViews<T extends StorageBrowserActions> = {
+    [K in keyof T['custom'] as K extends DefaultActionType<K> ? T['custom'][K] extends {
+        viewName: `${string}View`;
+    } ? T['custom'][K]['viewName'] : never : never]?: () => React.JSX.Element | null;
+};
+/**
+ * @internal @unstable
+ */
+export type DerivedActionViewType<T extends StorageBrowserActions> = keyof {
+    [K in keyof T['custom'] as K extends DefaultActionType<K> ? T['custom'][K] extends {
+        viewName: `${string}View`;
+    } ? K : never : never]?: any;
+} | Exclude<keyof DefaultActionConfigs, 'download'>;
+export interface CreateStorageBrowserOutput<C extends ExtendedActionConfigs = ExtendedActionConfigs> {
+    StorageBrowser: StorageBrowserType<DerivedActionViewType<C>, DerivedActionViews<C>>;
+    useAction: UseAction<DerivedActionHandlers<C>>;
+    useView: UseView;
+}
+export {};

package/dist/types/components/StorageBrowser/useAction/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_ACTION_CONCURRENCY = 4;
+export declare const USE_ACTION_ERROR_MESSAGE = "`useAction` must be called from within `StorageBrowser.Provider`";
+export declare const USE_LIST_ERROR_MESSAGE = "`useList` must be called from within `StorageBrowser.Provider`";

package/dist/types/components/StorageBrowser/useAction/context.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { ActionHandlersContext } from './types';
+export declare const ActionHandlersProvider: import("react").ComponentType<import("react").PropsWithChildren<ActionHandlersContext>>, useActionHandlers: (params?: {
+    errorMessage?: string | undefined;
+} | undefined) => ActionHandlersContext;

package/dist/types/components/StorageBrowser/useAction/createEnhancedListHandler.d.ts

@@ -0,0 +1,45 @@
+import { AsyncDataAction } from '@aws-amplify/ui-react-core';
+import { ListHandler, ListHandlerOptions, ListHandlerInput, ListHandlerOutput } from '../actions';
+type KeyWithStringValue<T> = keyof {
+    [P in keyof T as T[P] extends string ? P : never]: T[P];
+};
+interface SearchOptions<T> {
+    query: string;
+    /**
+     * The key of the object in the list to filter by, which must have a string value.
+     * Also accepts a function which takes an item and returns the appropriate key.
+     * This determines where the `query` will be searched.
+     */
+    filterBy: KeyWithStringValue<T> | ((item: T) => KeyWithStringValue<T>);
+    /**
+     * Optional delimiter to group item keys.
+     */
+    groupBy?: string;
+}
+export interface EnhancedListHandlerOptions<T, K> extends ListHandlerOptions<K> {
+    refresh?: boolean;
+    reset?: boolean;
+    search?: SearchOptions<T>;
+}
+export interface SearchOutput {
+    hasExhaustedSearch: boolean;
+}
+export interface EnhancedListHandlerOutput<T> extends ListHandlerOutput<T> {
+    search?: SearchOutput;
+}
+export interface EnhancedListHandlerInput<T, K> extends Omit<ListHandlerInput<EnhancedListHandlerOptions<T, K>>, 'config'> {
+}
+export interface EnhancedListHandler<T, K> extends AsyncDataAction<EnhancedListHandlerOutput<T>, EnhancedListHandlerInput<T, K>> {
+}
+type ListItem<Action> = Action extends ListHandler<any, ListHandlerOutput<infer T>> ? T : never;
+type Options<Action> = Action extends ListHandler<Omit<ListHandlerInput<ListHandlerOptions<infer E>>, 'config'>> ? E : never;
+export declare const SEARCH_LIMIT = 10000;
+export declare const SEARCH_PAGE_SIZE = 1000;
+interface Search<T> {
+    prefix?: string;
+    list: T[];
+    options: SearchOptions<T>;
+}
+export declare function searchItems<T>({ prefix, list, options }: Search<T>): T[];
+export declare const createEnhancedListHandler: <Action extends ListHandler>(action: Action) => EnhancedListHandler<ListItem<Action>, Options<Action>>;
+export {};

package/dist/types/components/StorageBrowser/useAction/index.d.ts

@@ -0,0 +1,6 @@
+export { ActionHandlersProvider } from './context';
+export { createEnhancedListHandler } from './createEnhancedListHandler';
+export { ActionHandlersProviderProps, DefaultActionHandlers, DerivedActionHandlers, UseAction, } from './types';
+export { useAction } from './useAction';
+export { useList } from './useList';
+export { getActionHandlers } from './utils';

package/dist/types/components/StorageBrowser/useAction/types.d.ts

@@ -0,0 +1,76 @@
+import React from 'react';
+import { DataState } from '@aws-amplify/ui-react-core';
+import { ActionHandler, ExtendedActionConfigs, CopyHandler, CreateFolderHandler, DeleteHandler, DownloadHandler, ListLocationItemsHandler, ListLocations, LocationData, TaskData, UploadHandler } from '../actions';
+import { StatusCounts, Task, Tasks } from '../tasks';
+export type ListActionState<T = any, K = any> = [
+    state: DataState<T>,
+    handleAction: (...input: K[]) => void
+];
+export interface DefaultActionHandlers {
+    upload: UploadHandler;
+    download: DownloadHandler;
+    copy: CopyHandler;
+    createFolder: CreateFolderHandler;
+    delete: DeleteHandler;
+}
+export type ActionHandlers = Record<string, ActionHandler | ListLocationItemsHandler | ListLocations>;
+export interface ActionHandlersContext {
+    handlers: ActionHandlers;
+}
+export interface ActionHandlersProviderProps extends ActionHandlersContext {
+    children?: React.ReactNode;
+}
+type DerivedCustomActions<T> = T extends {
+    custom?: infer U;
+} ? U : {};
+export type ResolveHandlerType<T> = T extends {
+    handler: infer X;
+} | infer X ? X : never;
+export type DerivedActionHandlers<C extends ExtendedActionConfigs = ExtendedActionConfigs, D extends DerivedCustomActions<C> = DerivedCustomActions<C>> = DefaultActionHandlers & {
+    [K in keyof D]: ResolveHandlerType<D[K]>;
+};
+export interface HandleTasksOptions<U extends TaskData = TaskData> {
+    items: U[];
+    onTaskSuccess?: (task: Task<U>) => void;
+}
+interface HandleTasksInput {
+    location?: LocationData;
+}
+export interface HandleTaskInput<T, K> {
+    data: T;
+    location?: LocationData;
+    options?: {
+        onSuccess?: (data: {
+            id: string;
+            key: string;
+        }, value: K) => void;
+        onError?: (data: {
+            id: string;
+            key: string;
+        }, message: string | undefined) => void;
+    };
+}
+export type HandlerInput<T extends TaskData, K, U = undefined> = U extends undefined ? HandleTaskInput<T, K> : HandleTasksInput;
+export interface TasksState<T extends TaskData, V = any> {
+    isProcessing: boolean;
+    isProcessingComplete: boolean;
+    reset: () => void;
+    statusCounts: StatusCounts;
+    tasks: Tasks<T, V>;
+}
+export type HandleTasks = (input?: HandleTasksInput) => void;
+export type UseTasksState<T extends TaskData, V = any> = [
+    TasksState<T, V>,
+    HandleTasks
+];
+export type HandleTask<T, K> = (input: HandleTaskInput<T, K>) => void;
+export type UseTaskState<T extends TaskData, R> = [
+    {
+        task: Task<T, R> | undefined;
+        isProcessing: boolean;
+    },
+    HandleTask<T, R>
+];
+export type UseHandlerState<T extends TaskData, R, U = undefined> = U extends undefined ? UseTaskState<T, R> : UseTasksState<T, R>;
+export type UseAction<V extends Record<keyof V, ActionHandler>> = <K extends keyof V, TData extends V[K] extends ActionHandler<infer D> ? D & TaskData : never, TOptions extends HandleTasksOptions<TData>, U extends TOptions | undefined = undefined>(key: K, options?: U) => UseHandlerState<TData, V[K] extends ActionHandler<any, infer R> ? R : never, U>;
+export {};

package/dist/types/components/StorageBrowser/useAction/useAction.d.ts

@@ -0,0 +1,3 @@
+import { DefaultActionHandlers, UseAction } from './types';
+export declare const ERROR_MESSAGE = "`useAction` must be called from within `StorageBrowser.Provider`";
+export declare const useAction: UseAction<DefaultActionHandlers>;

package/dist/types/components/StorageBrowser/useAction/useHandler.d.ts

@@ -0,0 +1,3 @@
+import { TaskData, TaskHandler, TaskHandlerInput, TaskHandlerOutput } from '../actions';
+import { HandleTasksOptions, UseHandlerState } from './types';
+export declare const useHandler: <TData extends TaskData, RValue, TOptions extends HandleTasksOptions<TData>, U extends TOptions | undefined = undefined>(action: TaskHandler<TaskHandlerInput<TData, import("../actions").TaskHandlerOptions<any>>, TaskHandlerOutput<RValue>>, options?: U | undefined) => UseHandlerState<TData, RValue, U>;

package/dist/types/components/StorageBrowser/useAction/useList.d.ts

@@ -0,0 +1,9 @@
+declare const LIST_ACTION_HOOKS: {
+    folderItems: () => import("./useListFolderItems").UseListFolderItemsState;
+    locationItems: () => import("./useListLocationItems").UseListLocationItemsState;
+    locations: () => import("./useListLocations").UseListLocationsState;
+};
+type ListActionHooks = typeof LIST_ACTION_HOOKS;
+export type UseList = <K extends keyof ListActionHooks, S extends ListActionHooks[K]>(type: K) => ReturnType<S>;
+export declare const useList: UseList;
+export {};

package/dist/types/components/StorageBrowser/useAction/useListFolderItems.d.ts

@@ -0,0 +1,13 @@
+import { LocationItemType, FolderData, ListLocationItemsHandlerInput, ListHandlerOutput } from '../actions';
+import { EnhancedListHandlerInput, EnhancedListHandlerOutput } from './createEnhancedListHandler';
+import { ListActionState } from './types';
+type RemoveConfig<T> = Omit<T, 'config'>;
+interface EnhancedInput extends RemoveConfig<EnhancedListHandlerInput<FolderData, LocationItemType>> {
+}
+export interface UseListLocationItemsState extends ListActionState<EnhancedListHandlerOutput<FolderData>, EnhancedInput> {
+}
+export type ListFolderItemsAction = (input: ListLocationItemsHandlerInput) => Promise<ListHandlerOutput<FolderData>>;
+export interface UseListFolderItemsState extends ListActionState<EnhancedListHandlerOutput<FolderData>, EnhancedListHandlerInput<FolderData, LocationItemType>> {
+}
+export declare const useListFolderItems: () => UseListFolderItemsState;
+export {};

package/dist/types/components/StorageBrowser/useAction/useListLocationItems.d.ts

@@ -0,0 +1,10 @@
+import { LocationItemType, LocationItemData } from '../actions';
+import { EnhancedListHandlerInput, EnhancedListHandlerOutput } from './createEnhancedListHandler';
+import { ListActionState } from './types';
+type RemoveConfig<T> = Omit<T, 'config'>;
+interface EnhancedInput extends RemoveConfig<EnhancedListHandlerInput<LocationItemData, LocationItemType>> {
+}
+export interface UseListLocationItemsState extends ListActionState<EnhancedListHandlerOutput<LocationItemData>, EnhancedInput> {
+}
+export declare const useListLocationItems: () => UseListLocationItemsState;
+export {};

package/dist/types/components/StorageBrowser/useAction/useListLocations.d.ts

@@ -0,0 +1,8 @@
+import { LocationData, ListLocationsExcludeOptions } from '../actions';
+import { EnhancedListHandlerInput, EnhancedListHandlerOutput } from './createEnhancedListHandler';
+import { ListActionState } from './types';
+type RemoveConfigAndPrefix<T> = Omit<T, 'prefix' | 'config'>;
+export interface UseListLocationsState extends ListActionState<EnhancedListHandlerOutput<LocationData>, RemoveConfigAndPrefix<EnhancedListHandlerInput<LocationData, ListLocationsExcludeOptions>>> {
+}
+export declare const useListLocations: () => UseListLocationsState;
+export {};

package/dist/types/components/StorageBrowser/useAction/utils.d.ts

@@ -0,0 +1,6 @@
+import { CustomActionConfigs, ExtendedActionConfigs } from '../actions';
+import { ActionHandlers } from './types';
+export declare const getActionHandlers: <T extends {
+    default: Required<ExtendedActionConfigs>['default'];
+    custom?: CustomActionConfigs | undefined;
+}>(configs: T) => ActionHandlers;

package/dist/types/components/StorageBrowser/validators/assertAccountId.d.ts

@@ -0,0 +1 @@
+export declare function assertAccountId(value: string | undefined): asserts value is string;

package/dist/types/components/StorageBrowser/validators/assertLocationData.d.ts

@@ -0,0 +1,3 @@
+import { LocationData } from '../actions';
+export declare function assertLocationData(value: LocationData | undefined, message?: string): asserts value is LocationData;
+export declare function assertPrefix(value: string | undefined, message?: string): asserts value is string;

package/dist/types/components/StorageBrowser/validators/assertRegisterAuthListener.d.ts

@@ -0,0 +1,2 @@
+import { RegisterAuthListener } from '../providers';
+export declare function assertRegisterAuthListener(value: unknown): asserts value is RegisterAuthListener;

package/dist/types/components/StorageBrowser/validators/index.d.ts

@@ -0,0 +1,4 @@
+export { assertLocationData } from './assertLocationData';
+export { assertRegisterAuthListener } from './assertRegisterAuthListener';
+export { assertAccountId } from './assertAccountId';
+export { isFileTooBig } from './isFileTooBig';

package/dist/types/components/StorageBrowser/validators/isFileTooBig.d.ts

@@ -0,0 +1,2 @@
+export declare const UPLOAD_FILE_SIZE_LIMIT: number;
+export declare const isFileTooBig: (file: File) => boolean;

package/dist/types/components/StorageBrowser/views/LocationActionView/CopyView/CopyView.d.ts

@@ -0,0 +1,2 @@
+import { CopyViewType } from './types';
+export declare const CopyView: CopyViewType;

package/dist/types/components/StorageBrowser/views/LocationActionView/CopyView/CopyViewProvider.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { CopyViewProviderProps } from './types';
+export declare function CopyViewProvider({ children, ...props }: CopyViewProviderProps): React.JSX.Element;