squarefi-bff-api-module 1.29.0 → 1.29.2

package/dist/api/types/types.d.ts

@@ -1677,7 +1677,7 @@ export declare namespace API {
                 walletAddress: string;
             }
             namespace DepositInstruction {
-                type InstructionType = 'ACH' | 'FEDWIRE' | 'SWIFT';
+                type InstructionType = 'ACH' | 'FEDWIRE' | 'SWIFT' | 'SEPA_CT';
                 interface Address {
                     city: string;
                     state: string;
@@ -1697,6 +1697,7 @@ export declare namespace API {
                     account_holder_name?: string;
                     account_routing_number?: string;
                     swift_bic?: string;
+                    iban?: string;
                 }
                 interface ACH extends Common {
                     instruction_type: 'ACH';
@@ -1714,6 +1715,13 @@ export declare namespace API {
                     institution_address: Address;
                     account_holder_address: Address;
                 }
+                interface SEPA extends Common {
+                    instruction_type: 'SEPA_CT';
+                    iban: string;
+                    swift_bic: string;
+                    institution_address: Address;
+                    account_holder_address: Address;
+                }
                 type DepositInstruction = ACH | FEDWIRE | SWIFT | Common;
             }
             interface OrderType {

package/dist/hooks/useFileUpload.d.ts

@@ -0,0 +1,34 @@
+import { UploadFileResult } from '../utils/fileStorage';
+interface UseFileUploadOptions {
+    userId: string;
+    bucket?: string;
+    authToken?: string;
+    onSuccess?: (result: UploadFileResult) => void;
+    onError?: (error: string) => void;
+}
+interface UseFileUploadReturn {
+    upload: (file: File, fileName?: string) => Promise<UploadFileResult>;
+    uploading: boolean;
+    progress: number;
+    error: string | null;
+    result: UploadFileResult | null;
+    reset: () => void;
+}
+/**
+ * React хук для загрузки файлов в Supabase Storage
+ *
+ * @example
+ * ```tsx
+ * const { upload, uploading, error, result } = useFileUpload({
+ *   userId: 'user-123',
+ *   onSuccess: (result) => console.log('Загружено:', result.path),
+ * });
+ *
+ * const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
+ *   const file = e.target.files?.[0];
+ *   if (file) await upload(file);
+ * };
+ * ```
+ */
+export declare const useFileUpload: (options: UseFileUploadOptions) => UseFileUploadReturn;
+export {};

package/dist/hooks/useFileUpload.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFileUpload = void 0;
+const react_1 = require("react");
+const fileStorage_1 = require("../utils/fileStorage");
+/**
+ * React хук для загрузки файлов в Supabase Storage
+ *
+ * @example
+ * ```tsx
+ * const { upload, uploading, error, result } = useFileUpload({
+ *   userId: 'user-123',
+ *   onSuccess: (result) => console.log('Загружено:', result.path),
+ * });
+ *
+ * const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
+ *   const file = e.target.files?.[0];
+ *   if (file) await upload(file);
+ * };
+ * ```
+ */
+const useFileUpload = (options) => {
+    const { userId, bucket, authToken, onSuccess, onError } = options;
+    const [uploading, setUploading] = (0, react_1.useState)(false);
+    const [progress, setProgress] = (0, react_1.useState)(0);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [result, setResult] = (0, react_1.useState)(null);
+    const upload = (0, react_1.useCallback)((file, customFileName) => __awaiter(void 0, void 0, void 0, function* () {
+        setUploading(true);
+        setProgress(0);
+        setError(null);
+        setResult(null);
+        try {
+            // Симулируем прогресс (Supabase не предоставляет реальный progress)
+            const progressInterval = setInterval(() => {
+                setProgress((prev) => Math.min(prev + 10, 90));
+            }, 100);
+            const uploadOptions = {
+                file,
+                fileName: customFileName || `${Date.now()}-${file.name}`,
+                userId,
+                bucket,
+                contentType: file.type,
+                authToken,
+            };
+            const uploadResult = yield (0, fileStorage_1.uploadFile)(uploadOptions);
+            clearInterval(progressInterval);
+            setProgress(100);
+            setResult(uploadResult);
+            if (uploadResult.success) {
+                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(uploadResult);
+            }
+            else {
+                const errorMsg = uploadResult.error || 'Ошибка загрузки файла';
+                setError(errorMsg);
+                onError === null || onError === void 0 ? void 0 : onError(errorMsg);
+            }
+            return uploadResult;
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : 'Непредвиденная ошибка';
+            setError(errorMsg);
+            onError === null || onError === void 0 ? void 0 : onError(errorMsg);
+            setProgress(0);
+            return {
+                success: false,
+                error: errorMsg,
+            };
+        }
+        finally {
+            setUploading(false);
+        }
+    }), [userId, bucket, authToken, onSuccess, onError]);
+    const reset = (0, react_1.useCallback)(() => {
+        setUploading(false);
+        setProgress(0);
+        setError(null);
+        setResult(null);
+    }, []);
+    return {
+        upload,
+        uploading,
+        progress,
+        error,
+        result,
+        reset,
+    };
+};
+exports.useFileUpload = useFileUpload;

package/dist/hooks/useUserFiles.d.ts

@@ -0,0 +1,49 @@
+interface FileItem {
+    name: string;
+    id: string;
+    created_at: string;
+    updated_at: string;
+    signedUrl?: string;
+}
+interface UseUserFilesOptions {
+    userId: string;
+    bucket?: string;
+    autoLoad?: boolean;
+    autoGenerateUrls?: boolean;
+    urlExpiresIn?: number;
+    authToken?: string;
+}
+interface UseUserFilesReturn {
+    files: FileItem[];
+    loading: boolean;
+    error: string | null;
+    reload: () => Promise<void>;
+    deleteOne: (fileName: string) => Promise<boolean>;
+    deleteMultiple: (fileNames: string[]) => Promise<boolean>;
+    getFileUrl: (fileName: string) => Promise<string | null>;
+}
+/**
+ * React хук для работы со списком файлов пользователя
+ *
+ * @example
+ * ```tsx
+ * const { files, loading, deleteOne, getFileUrl } = useUserFiles({
+ *   userId: 'user-123',
+ *   autoLoad: true,
+ *   autoGenerateUrls: true,
+ * });
+ *
+ * return (
+ *   <ul>
+ *     {files.map(file => (
+ *       <li key={file.id}>
+ *         <a href={file.signedUrl} target="_blank">{file.name}</a>
+ *         <button onClick={() => deleteOne(file.name)}>Удалить</button>
+ *       </li>
+ *     ))}
+ *   </ul>
+ * );
+ * ```
+ */
+export declare const useUserFiles: (options: UseUserFilesOptions) => UseUserFilesReturn;
+export {};

package/dist/hooks/useUserFiles.js

@@ -0,0 +1,118 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUserFiles = void 0;
+const react_1 = require("react");
+const fileStorage_1 = require("../utils/fileStorage");
+/**
+ * React хук для работы со списком файлов пользователя
+ *
+ * @example
+ * ```tsx
+ * const { files, loading, deleteOne, getFileUrl } = useUserFiles({
+ *   userId: 'user-123',
+ *   autoLoad: true,
+ *   autoGenerateUrls: true,
+ * });
+ *
+ * return (
+ *   <ul>
+ *     {files.map(file => (
+ *       <li key={file.id}>
+ *         <a href={file.signedUrl} target="_blank">{file.name}</a>
+ *         <button onClick={() => deleteOne(file.name)}>Удалить</button>
+ *       </li>
+ *     ))}
+ *   </ul>
+ * );
+ * ```
+ */
+const useUserFiles = (options) => {
+    const { userId, bucket, autoLoad = true, autoGenerateUrls = false, urlExpiresIn = 3600, authToken, } = options;
+    const [files, setFiles] = (0, react_1.useState)([]);
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const reload = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        setLoading(true);
+        setError(null);
+        try {
+            const userFiles = yield (0, fileStorage_1.listUserFiles)(userId, bucket, authToken);
+            let filesWithUrls = userFiles.map((file) => ({
+                name: file.name,
+                id: file.id,
+                created_at: file.created_at,
+                updated_at: file.updated_at,
+            }));
+            // Генерируем signed URLs если нужно
+            if (autoGenerateUrls) {
+                const filesWithSignedUrls = yield Promise.all(filesWithUrls.map((file) => __awaiter(void 0, void 0, void 0, function* () {
+                    const signedUrl = yield (0, fileStorage_1.getSignedUrl)({
+                        path: `${userId}/${file.name}`,
+                        bucket,
+                        expiresIn: urlExpiresIn,
+                        authToken,
+                    });
+                    return Object.assign(Object.assign({}, file), { signedUrl: signedUrl || undefined });
+                })));
+                filesWithUrls = filesWithSignedUrls;
+            }
+            setFiles(filesWithUrls);
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : 'Ошибка загрузки файлов';
+            setError(errorMsg);
+            console.error('Error loading files:', err);
+        }
+        finally {
+            setLoading(false);
+        }
+    }), [userId, bucket, autoGenerateUrls, urlExpiresIn, authToken]);
+    const deleteOne = (0, react_1.useCallback)((fileName) => __awaiter(void 0, void 0, void 0, function* () {
+        const filePath = `${userId}/${fileName}`;
+        const success = yield (0, fileStorage_1.deleteFile)(filePath, bucket, authToken);
+        if (success) {
+            setFiles((prev) => prev.filter((file) => file.name !== fileName));
+        }
+        return success;
+    }), [userId, bucket, authToken]);
+    const deleteMultiple = (0, react_1.useCallback)((fileNames) => __awaiter(void 0, void 0, void 0, function* () {
+        const filePaths = fileNames.map((name) => `${userId}/${name}`);
+        const success = yield (0, fileStorage_1.deleteFiles)(filePaths, bucket, authToken);
+        if (success) {
+            setFiles((prev) => prev.filter((file) => !fileNames.includes(file.name)));
+        }
+        return success;
+    }), [userId, bucket, authToken]);
+    const getFileUrl = (0, react_1.useCallback)((fileName) => __awaiter(void 0, void 0, void 0, function* () {
+        const filePath = `${userId}/${fileName}`;
+        return yield (0, fileStorage_1.getSignedUrl)({
+            path: filePath,
+            bucket,
+            expiresIn: urlExpiresIn,
+            authToken,
+        });
+    }), [userId, bucket, urlExpiresIn, authToken]);
+    (0, react_1.useEffect)(() => {
+        if (autoLoad) {
+            reload();
+        }
+    }, [autoLoad, reload]);
+    return {
+        files,
+        loading,
+        error,
+        reload,
+        deleteOne,
+        deleteMultiple,
+        getFileUrl,
+    };
+};
+exports.useUserFiles = useUserFiles;

package/dist/utils/fileStorage.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Типы для работы с файловым хранилищем
+ */
+export interface UploadFileOptions {
+    file: File | Blob;
+    fileName: string;
+    bucket?: string;
+    userId: string;
+    contentType?: string;
+    cacheControl?: string;
+    upsert?: boolean;
+    authToken?: string;
+}
+export interface UploadFileResult {
+    success: boolean;
+    publicUrl?: string;
+    signedUrl?: string;
+    path?: string;
+    error?: string;
+}
+export interface GetFileUrlOptions {
+    path: string;
+    bucket?: string;
+    expiresIn?: number;
+    authToken?: string;
+}
+/**
+ * Названия бакетов по умолчанию
+ */
+export declare const DEFAULT_BUCKET = "user-files";
+export declare const DOCUMENTS_BUCKET = "documents";
+export declare const IMAGES_BUCKET = "images";
+/**
+ * Загружает файл в Supabase Storage
+ * Файл сохраняется по пути: {userId}/{fileName}
+ *
+ * @param options - параметры загрузки файла
+ * @returns результат загрузки с ссылкой на файл
+ */
+export declare const uploadFile: (options: UploadFileOptions) => Promise<UploadFileResult>;
+/**
+ * Получает подписанный URL для доступа к файлу
+ *
+ * @param options - параметры получения URL
+ * @returns подписанный URL или null при ошибке
+ */
+export declare const getSignedUrl: (options: GetFileUrlOptions) => Promise<string | null>;
+/**
+ * Получает публичный URL для файла
+ *
+ * Для ПРИВАТНЫХ бакетов:
+ * - URL постоянный (не истекает)
+ * - Требует Authorization header с service role key для доступа
+ * - Используется на backend для суперадмина
+ *
+ * Для ПУБЛИЧНЫХ бакетов:
+ * - URL доступен всем без аутентификации
+ *
+ * @example Backend usage for private buckets:
+ * ```typescript
+ * const url = getPublicUrl(filePath, bucket);
+ *
+ * // Access with service role key:
+ * fetch(url, {
+ *   headers: {
+ *     'Authorization': `Bearer ${SUPABASE_SERVICE_ROLE_KEY}`
+ *   }
+ * })
+ * ```
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @returns постоянный URL
+ */
+export declare const getPublicUrl: (path: string, bucket?: string) => string | null;
+/**
+ * Удаляет файл из хранилища
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns true при успешном удалении
+ */
+export declare const deleteFile: (path: string, bucket?: string, authToken?: string) => Promise<boolean>;
+/**
+ * Удаляет несколько файлов из хранилища
+ *
+ * @param paths - массив путей к файлам
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns true при успешном удалении всех файлов
+ */
+export declare const deleteFiles: (paths: string[], bucket?: string, authToken?: string) => Promise<boolean>;
+/**
+ * Получает список файлов пользователя
+ *
+ * @param userId - ID пользователя
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns список файлов или пустой массив при ошибке
+ */
+export declare const listUserFiles: (userId: string, bucket?: string, authToken?: string) => Promise<import("@supabase/storage-js").FileObject[]>;
+/**
+ * Скачивает файл из хранилища
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns Blob файла или null при ошибке
+ */
+export declare const downloadFile: (path: string, bucket?: string, authToken?: string) => Promise<Blob | null>;

package/dist/utils/fileStorage.js

@@ -0,0 +1,342 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = exports.listUserFiles = exports.deleteFiles = exports.deleteFile = exports.getPublicUrl = exports.getSignedUrl = exports.uploadFile = exports.IMAGES_BUCKET = exports.DOCUMENTS_BUCKET = exports.DEFAULT_BUCKET = void 0;
+const supabase_1 = require("./supabase");
+/**
+ * Названия бакетов по умолчанию
+ */
+exports.DEFAULT_BUCKET = 'user-files';
+exports.DOCUMENTS_BUCKET = 'documents';
+exports.IMAGES_BUCKET = 'images';
+/**
+ * Загружает файл в Supabase Storage
+ * Файл сохраняется по пути: {userId}/{fileName}
+ *
+ * @param options - параметры загрузки файла
+ * @returns результат загрузки с ссылкой на файл
+ */
+const uploadFile = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { file, fileName, bucket = exports.DEFAULT_BUCKET, userId, contentType, cacheControl = '3600', upsert = false, authToken, } = options;
+    if (!supabase_1.supabaseClient) {
+        return {
+            success: false,
+            error: 'Supabase client is not initialized',
+        };
+    }
+    try {
+        // Если передан authToken, создаем клиент с токеном
+        let client = supabase_1.supabaseClient;
+        if (authToken) {
+            const { createClient } = yield Promise.resolve().then(() => __importStar(require('@supabase/supabase-js')));
+            client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PUBLIC_KEY, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                },
+            });
+        }
+        // Путь к файлу: userId/fileName
+        const filePath = `${userId}/${fileName}`;
+        const { data, error } = yield client.storage.from(bucket).upload(filePath, file, {
+            contentType,
+            cacheControl,
+            upsert,
+        });
+        if (error) {
+            console.error('Error uploading file:', error);
+            return {
+                success: false,
+                error: error.message,
+            };
+        }
+        // Получаем публичный URL
+        const { data: urlData } = client.storage.from(bucket).getPublicUrl(data.path);
+        // Получаем подписанный URL (действителен 1 час по умолчанию)
+        const { data: signedUrlData, error: signedUrlError } = yield client.storage
+            .from(bucket)
+            .createSignedUrl(data.path, 3600);
+        return {
+            success: true,
+            publicUrl: urlData.publicUrl,
+            signedUrl: signedUrlError ? undefined : signedUrlData.signedUrl,
+            path: data.path,
+        };
+    }
+    catch (error) {
+        console.error('Unexpected error uploading file:', error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+});
+exports.uploadFile = uploadFile;
+/**
+ * Получает подписанный URL для доступа к файлу
+ *
+ * @param options - параметры получения URL
+ * @returns подписанный URL или null при ошибке
+ */
+const getSignedUrl = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { path, bucket = exports.DEFAULT_BUCKET, expiresIn = 3600, authToken } = options;
+    if (!supabase_1.supabaseClient) {
+        console.error('Supabase client is not initialized');
+        return null;
+    }
+    try {
+        // Если передан authToken, создаем клиент с токеном
+        let client = supabase_1.supabaseClient;
+        if (authToken) {
+            const { createClient } = yield Promise.resolve().then(() => __importStar(require('@supabase/supabase-js')));
+            client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PUBLIC_KEY, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                },
+            });
+        }
+        const { data, error } = yield client.storage.from(bucket).createSignedUrl(path, expiresIn);
+        if (error) {
+            console.error('Error creating signed URL:', error);
+            return null;
+        }
+        return data.signedUrl;
+    }
+    catch (error) {
+        console.error('Unexpected error creating signed URL:', error);
+        return null;
+    }
+});
+exports.getSignedUrl = getSignedUrl;
+/**
+ * Получает публичный URL для файла
+ *
+ * Для ПРИВАТНЫХ бакетов:
+ * - URL постоянный (не истекает)
+ * - Требует Authorization header с service role key для доступа
+ * - Используется на backend для суперадмина
+ *
+ * Для ПУБЛИЧНЫХ бакетов:
+ * - URL доступен всем без аутентификации
+ *
+ * @example Backend usage for private buckets:
+ * ```typescript
+ * const url = getPublicUrl(filePath, bucket);
+ *
+ * // Access with service role key:
+ * fetch(url, {
+ *   headers: {
+ *     'Authorization': `Bearer ${SUPABASE_SERVICE_ROLE_KEY}`
+ *   }
+ * })
+ * ```
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @returns постоянный URL
+ */
+const getPublicUrl = (path, bucket = exports.DEFAULT_BUCKET) => {
+    if (!supabase_1.supabaseClient) {
+        console.error('Supabase client is not initialized');
+        return null;
+    }
+    const { data } = supabase_1.supabaseClient.storage.from(bucket).getPublicUrl(path);
+    return data.publicUrl;
+};
+exports.getPublicUrl = getPublicUrl;
+/**
+ * Удаляет файл из хранилища
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns true при успешном удалении
+ */
+const deleteFile = (path_1, ...args_1) => __awaiter(void 0, [path_1, ...args_1], void 0, function* (path, bucket = exports.DEFAULT_BUCKET, authToken) {
+    if (!supabase_1.supabaseClient) {
+        console.error('Supabase client is not initialized');
+        return false;
+    }
+    try {
+        let client = supabase_1.supabaseClient;
+        if (authToken) {
+            const { createClient } = yield Promise.resolve().then(() => __importStar(require('@supabase/supabase-js')));
+            client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PUBLIC_KEY, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                },
+            });
+        }
+        const { error } = yield client.storage.from(bucket).remove([path]);
+        if (error) {
+            console.error('Error deleting file:', error);
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Unexpected error deleting file:', error);
+        return false;
+    }
+});
+exports.deleteFile = deleteFile;
+/**
+ * Удаляет несколько файлов из хранилища
+ *
+ * @param paths - массив путей к файлам
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns true при успешном удалении всех файлов
+ */
+const deleteFiles = (paths_1, ...args_1) => __awaiter(void 0, [paths_1, ...args_1], void 0, function* (paths, bucket = exports.DEFAULT_BUCKET, authToken) {
+    if (!supabase_1.supabaseClient) {
+        console.error('Supabase client is not initialized');
+        return false;
+    }
+    try {
+        let client = supabase_1.supabaseClient;
+        if (authToken) {
+            const { createClient } = yield Promise.resolve().then(() => __importStar(require('@supabase/supabase-js')));
+            client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PUBLIC_KEY, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                },
+            });
+        }
+        const { error } = yield client.storage.from(bucket).remove(paths);
+        if (error) {
+            console.error('Error deleting files:', error);
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Unexpected error deleting files:', error);
+        return false;
+    }
+});
+exports.deleteFiles = deleteFiles;
+/**
+ * Получает список файлов пользователя
+ *
+ * @param userId - ID пользователя
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns список файлов или пустой массив при ошибке
+ */
+const listUserFiles = (userId_1, ...args_1) => __awaiter(void 0, [userId_1, ...args_1], void 0, function* (userId, bucket = exports.DEFAULT_BUCKET, authToken) {
+    if (!supabase_1.supabaseClient) {
+        console.error('Supabase client is not initialized');
+        return [];
+    }
+    try {
+        let client = supabase_1.supabaseClient;
+        if (authToken) {
+            const { createClient } = yield Promise.resolve().then(() => __importStar(require('@supabase/supabase-js')));
+            client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PUBLIC_KEY, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                },
+            });
+        }
+        const { data, error } = yield client.storage.from(bucket).list(userId);
+        if (error) {
+            console.error('Error listing files:', error);
+            return [];
+        }
+        return data || [];
+    }
+    catch (error) {
+        console.error('Unexpected error listing files:', error);
+        return [];
+    }
+});
+exports.listUserFiles = listUserFiles;
+/**
+ * Скачивает файл из хранилища
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns Blob файла или null при ошибке
+ */
+const downloadFile = (path_1, ...args_1) => __awaiter(void 0, [path_1, ...args_1], void 0, function* (path, bucket = exports.DEFAULT_BUCKET, authToken) {
+    if (!supabase_1.supabaseClient) {
+        console.error('Supabase client is not initialized');
+        return null;
+    }
+    try {
+        let client = supabase_1.supabaseClient;
+        if (authToken) {
+            const { createClient } = yield Promise.resolve().then(() => __importStar(require('@supabase/supabase-js')));
+            client = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_PUBLIC_KEY, {
+                global: {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                },
+            });
+        }
+        const { data, error } = yield client.storage.from(bucket).download(path);
+        if (error) {
+            console.error('Error downloading file:', error);
+            return null;
+        }
+        return data;
+    }
+    catch (error) {
+        console.error('Unexpected error downloading file:', error);
+        return null;
+    }
+});
+exports.downloadFile = downloadFile;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squarefi-bff-api-module",
-  "version": "1.29.0",
+  "version": "1.29.2",
   "description": "Squarefi BFF API client module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/api/types/types.ts

@@ -2163,7 +2163,7 @@ export namespace API {
       }
 
       export namespace DepositInstruction {
-        export type InstructionType = 'ACH' | 'FEDWIRE' | 'SWIFT';
+        export type InstructionType = 'ACH' | 'FEDWIRE' | 'SWIFT' | 'SEPA_CT';
 
         export interface Address {
           city: string;
@@ -2185,6 +2185,7 @@ export namespace API {
           account_holder_name?: string;
           account_routing_number?: string;
           swift_bic?: string;
+          iban?: string;
         }
         export interface ACH extends Common {
           instruction_type: 'ACH';
@@ -2203,6 +2204,13 @@ export namespace API {
           institution_address: Address;
           account_holder_address: Address;
         }
+        export interface SEPA extends Common {
+          instruction_type: 'SEPA_CT';
+          iban: string;
+          swift_bic: string;
+          institution_address: Address;
+          account_holder_address: Address;
+        }
 
         export type DepositInstruction = ACH | FEDWIRE | SWIFT | Common;
       }