@scality/data-browser-library 1.0.0-preview.8 → 1.0.1

package/dist/components/ui/FilterFormSection.js

@@ -0,0 +1,159 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { FormGroup, FormSection, Stack, Text } from "@scality/core-ui";
+import { convertRemToPixels } from "@scality/core-ui/dist/components/tablev2/TableUtils";
+import { Box, Input, Select } from "@scality/core-ui/dist/next";
+import { ArrayFieldActions } from "./ArrayFieldActions.js";
+const filterTypeOptions = [
+    {
+        value: 'none',
+        label: 'All objects'
+    },
+    {
+        value: 'prefix',
+        label: 'Prefix filter'
+    },
+    {
+        value: 'tags',
+        label: 'Tags filter'
+    },
+    {
+        value: 'and',
+        label: 'Prefix and tags filter'
+    }
+];
+const shouldShowPrefix = (filterType)=>'prefix' === filterType || 'and' === filterType;
+const shouldShowTags = (filterType)=>'tags' === filterType || 'and' === filterType;
+function FilterFormSection({ filterType, onFilterTypeChange, prefixRegister, tagFields, tagKeyRegister, tagValueRegister, getTagKeyValue, getTagValueValue, appendTag, removeTag, errors, forceLabelWidth = convertRemToPixels(15) }) {
+    return /*#__PURE__*/ jsxs(FormSection, {
+        title: {
+            name: 'Filter'
+        },
+        forceLabelWidth: forceLabelWidth,
+        children: [
+            /*#__PURE__*/ jsx(FormGroup, {
+                label: "Filter",
+                id: "filterType",
+                direction: "horizontal",
+                content: /*#__PURE__*/ jsx(Select, {
+                    id: "filterType",
+                    value: filterType,
+                    onChange: onFilterTypeChange,
+                    children: filterTypeOptions.map((option)=>/*#__PURE__*/ jsx(Select.Option, {
+                            value: option.value,
+                            children: option.label
+                        }, option.value))
+                })
+            }),
+            shouldShowPrefix(filterType) ? /*#__PURE__*/ jsx(FormGroup, {
+                label: "Prefix",
+                id: "prefix",
+                direction: "horizontal",
+                error: errors?.prefix?.message,
+                helpErrorPosition: "bottom",
+                required: 'prefix' === filterType,
+                content: /*#__PURE__*/ jsx(Input, {
+                    id: "prefix",
+                    placeholder: "folder/",
+                    ...prefixRegister
+                })
+            }) : /*#__PURE__*/ jsx(Fragment, {}),
+            shouldShowTags(filterType) ? /*#__PURE__*/ jsx(FormGroup, {
+                label: "Tags",
+                id: "tags",
+                direction: "horizontal",
+                error: errors?.tags?.message,
+                helpErrorPosition: "bottom",
+                required: true,
+                content: /*#__PURE__*/ jsxs(Stack, {
+                    direction: "vertical",
+                    gap: "r8",
+                    children: [
+                        /*#__PURE__*/ jsxs(Stack, {
+                            gap: "r8",
+                            children: [
+                                /*#__PURE__*/ jsx(Box, {
+                                    flex: "1",
+                                    children: /*#__PURE__*/ jsx(Text, {
+                                        color: "textSecondary",
+                                        children: "Key"
+                                    })
+                                }),
+                                /*#__PURE__*/ jsx(Box, {
+                                    flex: "1",
+                                    children: /*#__PURE__*/ jsx(Text, {
+                                        color: "textSecondary",
+                                        children: "Value"
+                                    })
+                                }),
+                                /*#__PURE__*/ jsx(Box, {
+                                    width: "80px"
+                                })
+                            ]
+                        }),
+                        tagFields.map((field, index)=>/*#__PURE__*/ jsxs(Stack, {
+                                gap: "r8",
+                                children: [
+                                    /*#__PURE__*/ jsx(Input, {
+                                        id: `tag-key-${index}`,
+                                        placeholder: "Key",
+                                        size: "1/2",
+                                        ...tagKeyRegister(index)
+                                    }),
+                                    /*#__PURE__*/ jsx(Input, {
+                                        id: `tag-value-${index}`,
+                                        placeholder: "Value",
+                                        size: "1/2",
+                                        ...tagValueRegister(index)
+                                    }),
+                                    /*#__PURE__*/ jsx(ArrayFieldActions, {
+                                        showAdd: index === tagFields.length - 1,
+                                        onRemove: ()=>removeTag(index),
+                                        onAdd: ()=>appendTag({
+                                                key: '',
+                                                value: ''
+                                            }),
+                                        canRemove: tagFields.length > 1,
+                                        canAdd: !!getTagKeyValue(index) && !!getTagValueValue(index),
+                                        removeLabel: "Remove tag",
+                                        addLabel: "Add tag"
+                                    })
+                                ]
+                            }, field.id))
+                    ]
+                })
+            }) : /*#__PURE__*/ jsx(Fragment, {})
+        ]
+    });
+}
+const createFilterValidationSchema = (Joi)=>({
+        filterType: Joi.string().valid('none', 'prefix', 'tags', 'and').required(),
+        prefix: Joi.when('filterType', {
+            is: 'prefix',
+            then: Joi.string().required().min(1).messages({
+                'string.empty': 'Prefix is required when using prefix filter',
+                'string.min': 'Prefix is required when using prefix filter'
+            }),
+            otherwise: Joi.when('filterType', {
+                is: 'and',
+                then: Joi.string().allow('').optional(),
+                otherwise: Joi.any()
+            })
+        }),
+        tags: Joi.when('filterType', {
+            is: Joi.valid('tags', 'and'),
+            then: Joi.array().items(Joi.object({
+                key: Joi.string().required().max(128).messages({
+                    'string.empty': 'Tag key is required',
+                    'string.max': 'Tag key must not exceed 128 characters'
+                }),
+                value: Joi.string().required().max(256).messages({
+                    'string.empty': 'Tag value is required',
+                    'string.max': 'Tag value must not exceed 256 characters'
+                })
+            })).min(1).messages({
+                'array.min': 'At least one tag is required when using tag filter'
+            }),
+            otherwise: Joi.array().optional()
+        })
+    });
+export { FilterFormSection, createFilterValidationSchema };

package/dist/components/ui/Search.elements.d.ts

@@ -1,4 +1,4 @@
-import { IconColor, IconName } from "@scality/core-ui/dist/components/icon/Icon.component";
+import type { IconColor, IconName } from '@scality/core-ui/dist/components/icon/Icon.component';
 export declare const SearchContainer: import("styled-components").StyledComponent<"form", any, {
     isHidden?: boolean;
 }, never>;
@@ -10,7 +10,7 @@ type SearchIcon = {
     name: IconName;
     color: IconColor;
 };
-export declare const searchIcon: ({ isMetadata, isError, }: {
+export declare const searchIcon: ({ isMetadata, isError }: {
     isMetadata: boolean;
     isError: boolean;
 }) => SearchIcon;

package/dist/components/ui/Search.elements.js

@@ -5,7 +5,7 @@ const SearchContainer = styled_components.form`
   display: flex;
   max-width: 600px;
   margin-right: ${spacing.r20};
-  visibility: ${(props)=>props.isHidden ? "hidden" : "visible"};
+  visibility: ${(props)=>props.isHidden ? 'hidden' : 'visible'};
   gap: ${spacing.r8};
 `;
 const SearchInputContainer = styled_components.div`
@@ -44,16 +44,16 @@ const HintsTitle = styled_components.div`
 `;
 const searchIcon = ({ isMetadata, isError })=>{
     if (isError) return {
-        name: "Close",
-        color: "statusCritical"
+        name: 'Close',
+        color: 'statusCritical'
     };
     if (isMetadata) return {
-        name: "Check",
-        color: "statusHealthy"
+        name: 'Check',
+        color: 'statusHealthy'
     };
     return {
-        name: "Search",
-        color: "textSecondary"
+        name: 'Search',
+        color: 'textSecondary'
     };
 };
 export { HintItem, HintsContainer, HintsTitle, SearchContainer, SearchInputContainer, searchIcon };

package/dist/components/ui/Table.elements.d.ts

@@ -7,8 +7,9 @@ export declare const Body: ({ children, ...props }: {
 export declare const Group: ({ children, ...props }: {
     children: React.ReactNode;
 }) => import("react/jsx-runtime").JSX.Element;
-export declare const GroupName: ({ children, ...props }: {
+export declare const GroupName: ({ children, action, ...props }: {
     children: React.ReactNode;
+    action?: React.ReactNode;
 }) => import("react/jsx-runtime").JSX.Element;
 export declare const GroupContent: ({ children, ...props }: {
     children: React.ReactNode;

package/dist/components/ui/Table.elements.js

@@ -1,4 +1,4 @@
-import { jsx } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
 import { Text, spacing } from "@scality/core-ui";
 import { Box } from "@scality/core-ui/dist/next";
 import styled_components from "styled-components";
@@ -20,14 +20,20 @@ const Group = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
         ...props,
         children: children
     });
-const GroupName = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
+const GroupName = ({ children, action, ...props })=>/*#__PURE__*/ jsxs(Box, {
+        display: "flex",
+        justifyContent: "space-between",
+        alignItems: "center",
         marginBottom: spacing.r10,
         ...props,
-        children: /*#__PURE__*/ jsx(Text, {
-            isEmphazed: true,
-            color: "textPrimary",
-            children: children
-        })
+        children: [
+            /*#__PURE__*/ jsx(Text, {
+                isEmphazed: true,
+                color: "textPrimary",
+                children: children
+            }),
+            action
+        ]
     });
 const GroupContent = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
         display: "flex",
@@ -47,16 +53,16 @@ const Row = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
     });
 const RawKey = styled_components.div`
   color: ${(props)=>props.principal ? props.theme.textPrimary : props.theme?.textSecondary};
-  font-weight: ${(props)=>props.principal ? "bold" : "normal"};
+  font-weight: ${(props)=>props.principal ? 'bold' : 'normal'};
   ${(props)=>props.required ? `
         &:after {
             content: '*';
         }
-    ` : ""}
+    ` : ''}
 `;
 const Key = styled_components(RawKey)`
   && {
-    flex: ${(props)=>props.size || "0.35"};
+    flex: ${(props)=>props.size || '0.35'};
     min-width: 0;
   }
 `;
@@ -76,12 +82,12 @@ const TableContainer = ({ children, ...props })=>/*#__PURE__*/ jsx(Box, {
     });
 const GroupValues = styled_components.div`
   display: flex;
-  flex: ${(props)=>props.size || "0.65"};
+  flex: ${(props)=>props.size || '0.65'};
   justify-content: space-between;
   align-items: center;
   min-width: 0;
 `;
 const ExtraCell = styled_components.div`
-  margin-left: ${(props)=>props.marginLeft || "1.429rem"};
+  margin-left: ${(props)=>props.marginLeft || '1.429rem'};
 `;
 export { Body, ExtraCell, Group, GroupContent, GroupName, GroupValues, Key, Row, Table, TableContainer, Value };

package/dist/config/__tests__/factory.test.d.ts

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

package/dist/config/__tests__/factory.test.js

@@ -0,0 +1,311 @@
+import { HttpResponse, http } from "msw";
+import { setupServer } from "msw/node";
+import { loadRuntimeConfig, s3RuntimeConfigSchema } from "../factory.js";
+const server = setupServer();
+const CONFIG_URL = 'http://localhost/config.json';
+describe('loadRuntimeConfig', ()=>{
+    beforeAll(()=>server.listen({
+            onUnhandledRequest: 'error'
+        }));
+    afterEach(()=>server.resetHandlers());
+    afterAll(()=>server.close());
+    describe('Successful configuration loading', ()=>{
+        it('should load and return valid runtime configuration', async ()=>{
+            const mockConfig = {
+                s3: {
+                    endpoint: 'https://s3.us-west-2.amazonaws.com',
+                    region: 'us-west-2',
+                    forcePathStyle: true
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config).toEqual(mockConfig);
+            expect(config.s3.endpoint).toBe('https://s3.us-west-2.amazonaws.com');
+            expect(config.s3.region).toBe('us-west-2');
+            expect(config.s3.forcePathStyle).toBe(true);
+        });
+        it('should support generic type for extended configuration', async ()=>{
+            const mockConfig = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com',
+                    region: 'us-east-1'
+                },
+                basePath: '/app',
+                theme: 'dark',
+                customSettings: {
+                    feature1: true,
+                    feature2: 42
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.basePath).toBe('/app');
+            expect(config.theme).toBe('dark');
+            expect(config.customSettings).toEqual({
+                feature1: true,
+                feature2: 42
+            });
+        });
+        it('should replace "origin" endpoint with window.location.origin', async ()=>{
+            const mockConfig = {
+                s3: {
+                    endpoint: 'origin',
+                    region: 'us-east-1'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.s3.endpoint).not.toBe('origin');
+            expect(config.s3.endpoint).toBe(window.location.origin);
+            expect(config.s3.endpoint).toMatch(/^http/);
+        });
+        it('should handle configuration without optional forcePathStyle', async ()=>{
+            const mockConfig = {
+                s3: {
+                    endpoint: 'https://s3.ap-northeast-1.amazonaws.com',
+                    region: 'ap-northeast-1'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.s3.forcePathStyle).toBeUndefined();
+            expect(config.s3.endpoint).toBe('https://s3.ap-northeast-1.amazonaws.com');
+        });
+        it('should handle configuration without endpoint', async ()=>{
+            const mockConfig = {
+                s3: {
+                    region: 'us-east-1'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.s3.endpoint).toBeUndefined();
+            expect(config.s3.region).toBe('us-east-1');
+        });
+    });
+    describe('HTTP errors', ()=>{
+        it("should throw descriptive error when fetch returns 404", async ()=>{
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(null, {
+                    status: 404
+                })));
+            await expect(loadRuntimeConfig(CONFIG_URL)).rejects.toThrow('Failed to load config: Not Found');
+        });
+        it("should throw descriptive error when fetch returns 500", async ()=>{
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(null, {
+                    status: 500
+                })));
+            await expect(loadRuntimeConfig(CONFIG_URL)).rejects.toThrow('Failed to load config: Internal Server Error');
+        });
+        it('should throw error when fetch returns 403', async ()=>{
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(null, {
+                    status: 403
+                })));
+            await expect(loadRuntimeConfig(CONFIG_URL)).rejects.toThrow('Failed to load config: Forbidden');
+        });
+        it('should throw error when response is network error', async ()=>{
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.error()));
+            await expect(loadRuntimeConfig(CONFIG_URL)).rejects.toThrow();
+        });
+    });
+    describe('Validation errors', ()=>{
+        it('should reject config missing required s3.region field', async ()=>{
+            const invalidConfig = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(invalidConfig)));
+            const error = await loadRuntimeConfig(CONFIG_URL).catch((e)=>e);
+            expect(error).toBeInstanceOf(Error);
+            expect(error.message).toContain('Invalid config');
+            expect(error.message).toContain('region');
+        });
+        it('should reject config completely missing s3 section', async ()=>{
+            const invalidConfig = {
+                someOtherField: 'value',
+                anotherField: 123
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(invalidConfig)));
+            const error = await loadRuntimeConfig(CONFIG_URL).catch((e)=>e);
+            expect(error).toBeInstanceOf(Error);
+            expect(error.message).toContain('Invalid config');
+            expect(error.message).toContain('s3');
+        });
+        it('should reject config with invalid region type', async ()=>{
+            const invalidConfig = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com',
+                    region: 123
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(invalidConfig)));
+            const error = await loadRuntimeConfig(CONFIG_URL).catch((e)=>e);
+            expect(error).toBeInstanceOf(Error);
+            expect(error.message).toContain('Invalid config');
+        });
+        it('should reject config with invalid forcePathStyle type', async ()=>{
+            const invalidConfig = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com',
+                    region: 'us-east-1',
+                    forcePathStyle: 'yes'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(invalidConfig)));
+            const error = await loadRuntimeConfig(CONFIG_URL).catch((e)=>e);
+            expect(error).toBeInstanceOf(Error);
+            expect(error.message).toContain('Invalid config');
+        });
+    });
+    describe('Edge cases', ()=>{
+        it('should handle empty s3 object with only region', async ()=>{
+            const mockConfig = {
+                s3: {
+                    region: 'eu-west-1'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.s3.region).toBe('eu-west-1');
+            expect(config.s3.endpoint).toBeUndefined();
+            expect(config.s3.forcePathStyle).toBeUndefined();
+        });
+        it('should preserve all unknown fields for extended configs', async ()=>{
+            const mockConfig = {
+                s3: {
+                    region: 'us-east-1'
+                },
+                customField1: 'value1',
+                customField2: 42,
+                nested: {
+                    field: true
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.customField1).toBe('value1');
+            expect(config.customField2).toBe(42);
+            expect(config.nested).toEqual({
+                field: true
+            });
+        });
+        it('should not modify original endpoint when not "origin"', async ()=>{
+            const originalEndpoint = 'https://custom-s3.example.com:9000';
+            const mockConfig = {
+                s3: {
+                    endpoint: originalEndpoint,
+                    region: 'us-east-1'
+                }
+            };
+            server.use(http.get(CONFIG_URL, ()=>HttpResponse.json(mockConfig)));
+            const config = await loadRuntimeConfig(CONFIG_URL);
+            expect(config.s3.endpoint).toBe(originalEndpoint);
+        });
+    });
+});
+describe('s3RuntimeConfigSchema', ()=>{
+    describe('Valid configurations', ()=>{
+        it('should validate complete configuration with all fields', ()=>{
+            const config = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com',
+                    region: 'us-east-1',
+                    forcePathStyle: true
+                }
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config);
+            expect(error).toBeUndefined();
+        });
+        it('should validate minimal configuration with only required fields', ()=>{
+            const config = {
+                s3: {
+                    region: 'eu-west-1'
+                }
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config);
+            expect(error).toBeUndefined();
+        });
+        it('should allow unknown fields when allowUnknown is true', ()=>{
+            const config = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com',
+                    region: 'us-east-1'
+                },
+                customField: 'value',
+                anotherField: 123
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config, {
+                allowUnknown: true
+            });
+            expect(error).toBeUndefined();
+        });
+    });
+    describe('Invalid configurations', ()=>{
+        it('should reject config without s3.region', ()=>{
+            const config = {
+                s3: {
+                    endpoint: 'https://s3.amazonaws.com'
+                }
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config);
+            expect(error).toBeDefined();
+            expect(error?.details[0].path).toContain('region');
+            expect(error?.message).toContain('region');
+        });
+        it('should reject config without s3 object', ()=>{
+            const config = {};
+            const { error } = s3RuntimeConfigSchema.validate(config);
+            expect(error).toBeDefined();
+            expect(error?.details[0].path).toContain('s3');
+        });
+        it('should reject config with wrong type for region', ()=>{
+            const config = {
+                s3: {
+                    region: 123
+                }
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config);
+            expect(error).toBeDefined();
+            expect(error?.message).toContain('string');
+        });
+        it('should reject config with wrong type for forcePathStyle', ()=>{
+            const config = {
+                s3: {
+                    region: 'us-east-1',
+                    forcePathStyle: 'not-a-boolean'
+                }
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config, {
+                convert: false
+            });
+            expect(error).toBeDefined();
+            expect(error?.message).toContain('boolean');
+        });
+    });
+    describe('Schema behavior', ()=>{
+        it('should return all validation errors when abortEarly is false', ()=>{
+            const config = {
+                s3: {}
+            };
+            const { error } = s3RuntimeConfigSchema.validate(config, {
+                abortEarly: false
+            });
+            expect(error).toBeDefined();
+            expect(error?.details.length).toBeGreaterThanOrEqual(1);
+        });
+        it('should preserve unknown fields when stripUnknown is false', ()=>{
+            const config = {
+                s3: {
+                    region: 'us-east-1'
+                },
+                customField: 'should-be-kept'
+            };
+            const { value } = s3RuntimeConfigSchema.validate(config, {
+                allowUnknown: true,
+                stripUnknown: false
+            });
+            expect(value.customField).toBe('should-be-kept');
+        });
+    });
+});

package/dist/config/factory.d.ts

@@ -1,52 +1,17 @@
-import type { S3ClientConfiguration } from "./types";
-import type { S3BrowserConfig, S3Credentials } from "../types";
-/**
- * Configuration factory that uses build-time constants
- * No runtime environment detection or hardcoded values
- */
-export declare class S3ConfigurationFactory {
-    /**
-     * Load runtime configuration from config.json
-     * Should be called at app startup
-     */
-    static loadRuntimeConfig(): Promise<void>;
-    private static getBuildTimeConfig;
-    /**
-     * Create S3 client configuration based on build-time settings
-     */
-    static createClientConfiguration(credentials: S3Credentials): S3BrowserConfig & {
-        credentials: S3Credentials;
-    };
-    /**
-     * Create proxy middleware configuration
-     */
-    static createProxyConfiguration(): S3ClientConfiguration;
-    /**
-     * Check if proxy middleware should be enabled
-     */
-    static shouldUseProxyMiddleware(): boolean;
-    /**
-     * Get build-time environment info for debugging
-     */
-    static getBuildInfo(): {
-        environment: string;
-        useProxy: boolean;
-        s3Endpoint: string;
-        proxyEndpoint: string | undefined;
+import Joi from 'joi';
+export type S3RuntimeConfig = {
+    s3: {
+        endpoint?: string;
+        region: string;
+        forcePathStyle?: boolean;
     };
-}
+};
+export declare const s3RuntimeConfigSchema: Joi.ObjectSchema<any>;
 /**
- * Convenience functions for common use cases
+ * Load runtime configuration from config.json
+ *
+ * @template T - Extended runtime config type that must include S3RuntimeConfig
+ * @param configUrl - URL to fetch the config.json from
+ * @returns Promise resolving to the loaded config
  */
-export declare const createS3Config: (credentials: S3Credentials) => S3BrowserConfig & {
-    credentials: S3Credentials;
-};
-export declare const shouldUseProxy: () => boolean;
-export declare const getProxyConfig: () => S3ClientConfiguration;
-export declare const getBuildInfo: () => {
-    environment: string;
-    useProxy: boolean;
-    s3Endpoint: string;
-    proxyEndpoint: string | undefined;
-};
-export declare const loadRuntimeConfig: () => Promise<void>;
+export declare function loadRuntimeConfig<T extends S3RuntimeConfig = S3RuntimeConfig>(configUrl: string): Promise<T>;