@babelize/engine 0.0.0-stage → 0.1.2

package/dist/utils/ast-helpers.js

@@ -0,0 +1,608 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverse = exports.t = exports.generate = void 0;
+exports.parseCode = parseCode;
+exports.generateCode = generateCode;
+exports.placeStatementsOnOwnLines = placeStatementsOnOwnLines;
+exports.isJSXText = isJSXText;
+exports.isAlreadyTranslated = isAlreadyTranslated;
+exports.isNonTranslatableContext = isNonTranslatableContext;
+exports.getComponentName = getComponentName;
+exports.isInsideComponent = isInsideComponent;
+exports.findComponentBody = findComponentBody;
+exports.hasTranslationImport = hasTranslationImport;
+exports.hasTranslationHook = hasTranslationHook;
+exports.createTranslationImport = createTranslationImport;
+exports.createTranslationHook = createTranslationHook;
+exports.createTCall = createTCall;
+exports.createJSXTCall = createJSXTCall;
+exports.extractJSXTextContent = extractJSXTextContent;
+exports.getParentContext = getParentContext;
+exports.extractExpressionContent = extractExpressionContent;
+exports.extractConditionalContent = extractConditionalContent;
+exports.hasUseClientDirective = hasUseClientDirective;
+const generator_1 = __importDefault(require("@babel/generator"));
+exports.generate = generator_1.default;
+const parser = __importStar(require("@babel/parser"));
+const traverse_1 = __importDefault(require("@babel/traverse"));
+exports.traverse = traverse_1.default;
+const t = __importStar(require("@babel/types"));
+exports.t = t;
+function parseCode(code, options = {}) {
+    const { sourceType = 'module', isTypeScript = options.filename ? !/\.jsx?$/i.test(options.filename) : true, isJSX = true } = options;
+    const plugins = [];
+    if (isJSX)
+        plugins.push('jsx');
+    if (isTypeScript)
+        plugins.push('typescript');
+    plugins.push('decorators-legacy', 'classProperties', 'classPrivateProperties', 'classPrivateMethods', 'exportDefaultFrom', 'exportNamespaceFrom', 'dynamicImport', 'nullishCoalescingOperator', 'optionalChaining', 'objectRestSpread');
+    return parser.parse(code, {
+        sourceType,
+        plugins,
+        errorRecovery: true,
+    });
+}
+function generateCode(ast, originalCode) {
+    const result = (0, generator_1.default)(ast, {
+        retainLines: true,
+        retainFunctionParens: true,
+        comments: true,
+        compact: false,
+    }, originalCode);
+    let code = result.code;
+    code = code.replace(/;import /g, ';\nimport ');
+    code = code.replace(/(^import .+;\n)([^i\n])/gm, '$1\n$2');
+    // An added import glued to the first statement: `import x from "y";export …`.
+    code = code.replace(/^(import\b[^\n]*?["'];)(?=[^\s/])/gm, '$1\n\n');
+    code = splitClosingBraces(code);
+    code = code.replace(/\n{3,}/g, '\n\n');
+    // retainLines drops the final newline; keep the file's own ending.
+    if (originalCode !== undefined && /\r?\n$/.test(originalCode) && !/\n$/.test(code)) {
+        code += originalCode.endsWith('\r\n') ? '\r\n' : '\n';
+    }
+    return code;
+}
+/**
+ * With `retainLines`, statements the injector adds (which have no source
+ * location) are printed on the line of the preceding token, e.g.
+ * `function Page() {const t = useTranslations();`. Move each such statement
+ * that directly follows a `{` onto its own line, indented like the body.
+ */
+function placeStatementsOnOwnLines(code, statements) {
+    if (statements.length === 0)
+        return code;
+    const eol = code.includes('\r\n') ? '\r\n' : '\n';
+    const lines = code.split(eol);
+    // The generator may print the same statement compactly or across lines
+    // (`const { t } = …` vs `const {\n  t\n} = …`): match on tokens, ignoring whitespace.
+    const escape = (x) => x.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const matchers = statements.map((text) => {
+        const tokens = text.split(/\s+/).filter(Boolean).map(escape).join('\\s*');
+        return { re: new RegExp(`\\{\\s*(${tokens})`) };
+    });
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        let hit = null;
+        for (const m of matchers) {
+            const found = m.re.exec(line);
+            if (found && (!hit || found.index < hit.at))
+                hit = { at: found.index, length: found[0].length - 1, text: found[1] };
+        }
+        if (!hit) {
+            out.push(line);
+            continue;
+        }
+        const lineIndent = line.match(/^\s*/)[0];
+        const next = lines.slice(i + 1).find((l) => l.trim().length > 0) ?? '';
+        const nextIndent = next.match(/^\s*/)[0];
+        const bodyIndent = nextIndent.length > lineIndent.length ? nextIndent : `${lineIndent}  `;
+        const rest = line.slice(hit.at + 1 + hit.length);
+        out.push(line.slice(0, hit.at + 1));
+        out.push(`${bodyIndent}${hit.text}`);
+        if (rest.trim()) {
+            // Anything else that followed on the line (rare) gets re-checked too.
+            lines.splice(i + 1, 0, `${bodyIndent}${rest.trim()}`);
+        }
+    }
+    return splitClosingBraces(out.join(eol));
+}
+/** A block body added around a concise arrow: `  return <jsx/>;};` → closing brace on its own line. */
+function splitClosingBraces(code) {
+    return code.replace(/^([ \t]+)(return\b[^\n]*;)(\};?)(\r?)$/gm, (_m, indent, stmt, close, cr) => `${indent}${stmt}${cr}\n${indent.slice(0, Math.max(0, indent.length - 2))}${close}${cr}`);
+}
+function isJSXText(node) {
+    return t.isJSXText(node);
+}
+function isAlreadyTranslated(node, path) {
+    if (path.parentPath?.isCallExpression()) {
+        const callee = path.parentPath.node.callee;
+        if (t.isIdentifier(callee) && callee.name === 't')
+            return true;
+        if (t.isMemberExpression(callee) &&
+            t.isIdentifier(callee.property) &&
+            callee.property.name === 't') {
+            return true;
+        }
+    }
+    let current = path;
+    while (current) {
+        if (current.isJSXElement()) {
+            const openingElement = current.node.openingElement;
+            if ((t.isJSXIdentifier(openingElement.name) && openingElement.name.name === 'Trans') ||
+                (t.isJSXMemberExpression(openingElement.name) && openingElement.name.property.name === 'Trans')) {
+                return true;
+            }
+        }
+        current = current.parentPath;
+    }
+    return false;
+}
+function isNonTranslatableContext(path) {
+    let current = path;
+    let isInFunctionOrClass = false;
+    let hasFunctionOrClassBetween = false;
+    while (current) {
+        if (current.isFunction() || current.isClass()) {
+            isInFunctionOrClass = true;
+            hasFunctionOrClassBetween = true;
+        }
+        if (current.isCallExpression()) {
+            const callee = current.node.callee;
+            if (t.isMemberExpression(callee) &&
+                t.isIdentifier(callee.object) &&
+                callee.object.name === 'console') {
+                return true;
+            }
+            if (t.isIdentifier(callee) && /^use[A-Z]/.test(callee.name)) {
+                if (!hasFunctionOrClassBetween) {
+                    return true;
+                }
+            }
+        }
+        if (current.isThrowStatement())
+            return true;
+        if (current.isNewExpression()) {
+            const callee = current.node.callee;
+            if (t.isIdentifier(callee) && /Error$/.test(callee.name))
+                return true;
+        }
+        if (current.isObjectProperty()) {
+            const propKey = current.node.key;
+            if ((t.isIdentifier(propKey) && propKey.name === 'key') ||
+                (t.isStringLiteral(propKey) && propKey.value === 'key')) {
+                return true;
+            }
+            // Exclude string values of known browser API parameter keys
+            // (e.g. { behavior: "smooth" } in scrollIntoView). Without this
+            // guard, translating "smooth" causes a runtime browser error since
+            // the browser API expects the literal string "smooth".
+            const TECH_OBJ_KEYS = new Set([
+                'behavior',
+                'easing',
+                'fill',
+                'direction',
+                'inline',
+                'block',
+                'scroll',
+            ]);
+            if ((t.isIdentifier(propKey) && TECH_OBJ_KEYS.has(propKey.name)) ||
+                (t.isStringLiteral(propKey) && TECH_OBJ_KEYS.has(propKey.value))) {
+                return true;
+            }
+        }
+        if (current.isMemberExpression() && current.node.computed && current.node.property === path.node) {
+            return true;
+        }
+        if (current.isSwitchCase() && current.node.test === path.node) {
+            return true;
+        }
+        if (current.isBinaryExpression() && ['===', '!==', '==', '!=', '>', '<', '>=', '<='].includes(current.node.operator)) {
+            return true;
+        }
+        if (current.isImportDeclaration())
+            return true;
+        if (current.isExportDeclaration() && !isInFunctionOrClass)
+            return true;
+        if (current.isTSTypeAnnotation() || current.isTSTypeLiteral() || current.isTypeAnnotation()) {
+            return true;
+        }
+        if (current.isJSXAttribute()) {
+            const nameNode = current.node.name;
+            if (t.isJSXIdentifier(nameNode)) {
+                const name = nameNode.name;
+                const NON_TRANSLATABLE_ATTRS = [
+                    'className',
+                    'class',
+                    'style',
+                    'key',
+                    'id',
+                    'ref',
+                    'src',
+                    'href',
+                    'to',
+                    'target',
+                    'rel',
+                    'type',
+                    'width',
+                    'height',
+                    'rows',
+                    'cols',
+                    'data-testid',
+                    'role',
+                    'as',
+                ];
+                if (NON_TRANSLATABLE_ATTRS.includes(name))
+                    return true;
+            }
+        }
+        current = current.parentPath;
+    }
+    return false;
+}
+function getComponentName(path) {
+    if (path.isVariableDeclarator()) {
+        if (t.isIdentifier(path.node.id))
+            return path.node.id.name;
+    }
+    if (path.isFunctionDeclaration()) {
+        if (path.node.id && t.isIdentifier(path.node.id))
+            return path.node.id.name;
+    }
+    if (path.isClassDeclaration()) {
+        return path.node.id?.name || null;
+    }
+    if (path.isExportDefaultDeclaration()) {
+        const declaration = path.node.declaration;
+        if (t.isFunctionDeclaration(declaration) && declaration.id)
+            return declaration.id.name;
+        if (t.isIdentifier(declaration))
+            return declaration.name;
+    }
+    return null;
+}
+function isInsideComponent(path) {
+    let current = path;
+    while (current) {
+        if (current.isReturnStatement()) {
+            const argument = current.node.argument;
+            if (t.isJSXElement(argument) || t.isJSXFragment(argument))
+                return true;
+        }
+        if (current.isFunction()) {
+            let name = null;
+            if (current.isFunctionDeclaration()) {
+                name = current.node.id?.name;
+            }
+            else if (current.isArrowFunctionExpression() ||
+                current.isFunctionExpression()) {
+                if (current.parentPath?.isVariableDeclarator()) {
+                    const id = current.parentPath.node.id;
+                    if (t.isIdentifier(id)) {
+                        name = id.name;
+                    }
+                }
+            }
+            if (name && /^[A-Z]/.test(name)) {
+                return true;
+            }
+            let hasJSX = false;
+            const checkJSX = (node) => {
+                if (!node || hasJSX)
+                    return;
+                // Skip descending into nested function or class boundaries
+                if (t.isFunctionDeclaration(node) ||
+                    t.isArrowFunctionExpression(node) ||
+                    t.isFunctionExpression(node) ||
+                    t.isClassDeclaration(node) ||
+                    t.isClassExpression(node)) {
+                    return;
+                }
+                if (t.isJSXElement(node) || t.isJSXFragment(node)) {
+                    hasJSX = true;
+                    return;
+                }
+                const obj = node;
+                for (const key in obj) {
+                    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                        const child = obj[key];
+                        if (Array.isArray(child)) {
+                            child.forEach(checkJSX);
+                        }
+                        else if (child && typeof child === 'object' && child !== null && typeof child.type === 'string') {
+                            checkJSX(child);
+                        }
+                    }
+                }
+            };
+            checkJSX(current.node.body);
+            if (hasJSX)
+                return true;
+        }
+        current = current.parentPath;
+    }
+    return false;
+}
+/** `memo(…)`, `React.forwardRef(…)`: wrappers whose function argument is the component. */
+function isComponentWrapperCall(call) {
+    if (!call.isCallExpression())
+        return false;
+    const callee = call.node.callee;
+    const name = t.isIdentifier(callee) ? callee.name : t.isMemberExpression(callee) && t.isIdentifier(callee.property) ? callee.property.name : '';
+    return /^(?:memo|forwardRef|observer)$/.test(name);
+}
+/** The function returns JSX from its own body (not from a nested function). */
+function returnsJsx(fn) {
+    if (!t.isBlockStatement(fn.node.body))
+        return t.isJSXElement(fn.node.body) || t.isJSXFragment(fn.node.body);
+    let found = false;
+    const isJsxish = (n) => !!n && (t.isJSXElement(n) || t.isJSXFragment(n) ||
+        (t.isConditionalExpression(n) && (isJsxish(n.consequent) || isJsxish(n.alternate))) ||
+        (t.isLogicalExpression(n) && (isJsxish(n.left) || isJsxish(n.right))) ||
+        (t.isParenthesizedExpression(n) && isJsxish(n.expression)));
+    fn.get('body').traverse({
+        Function(p) {
+            p.skip();
+        },
+        ReturnStatement(p) {
+            if (isJsxish(p.node.argument)) {
+                found = true;
+                p.stop();
+            }
+        },
+    });
+    return found;
+}
+/**
+ * Whether `fn` is a component the hook can go in: not a callback passed to
+ * another call (`items.map((x) => …)`, except memo/forwardRef), and either
+ * PascalCase-named, the default export, or returning JSX itself.
+ */
+function isComponentFunction(fn) {
+    const parent = fn.parentPath;
+    if (parent?.isCallExpression() && parent.node.arguments.includes(fn.node) && !isComponentWrapperCall(parent))
+        return false;
+    let name;
+    if (fn.isFunctionDeclaration())
+        name = fn.node.id?.name;
+    else {
+        let p = parent;
+        while (p && isComponentWrapperCall(p))
+            p = p.parentPath;
+        if (p?.isVariableDeclarator() && t.isIdentifier(p.node.id))
+            name = p.node.id.name;
+        if (p?.isExportDefaultDeclaration())
+            return true;
+    }
+    if (parent?.isExportDefaultDeclaration())
+        return true;
+    if (name && /^[A-Z]/.test(name))
+        return true;
+    return returnsJsx(fn);
+}
+/**
+ * The block body of the component `path` is in — where the translation hook
+ * goes. Skips callbacks (a hook inside `.map(…)` breaks the rules of hooks);
+ * null when there's no component with a block body.
+ */
+function findComponentBody(path) {
+    let current = path;
+    while (current) {
+        if (current.isArrowFunctionExpression() ||
+            current.isFunctionExpression() ||
+            current.isFunctionDeclaration()) {
+            const body = current.get('body');
+            if (!Array.isArray(body) && body.isBlockStatement() && isComponentFunction(current))
+                return body;
+        }
+        current = current.parentPath;
+    }
+    return null;
+}
+function hasTranslationImport(ast) {
+    let found = false;
+    (0, traverse_1.default)(ast, {
+        ImportDeclaration(path) {
+            if (path.node.source.value === 'react-i18next') {
+                path.node.specifiers.forEach((spec) => {
+                    if (t.isImportSpecifier(spec) &&
+                        t.isIdentifier(spec.imported) &&
+                        spec.imported.name === 'useTranslation') {
+                        found = true;
+                    }
+                });
+            }
+        },
+    });
+    return found;
+}
+function hasTranslationHook(functionPath) {
+    let found = false;
+    functionPath.traverse({
+        VariableDeclarator(path) {
+            const node = path.node;
+            if (node.init &&
+                t.isCallExpression(node.init) &&
+                t.isIdentifier(node.init.callee) &&
+                node.init.callee.name === 'useTranslation') {
+                found = true;
+            }
+        },
+    });
+    return found;
+}
+function createTranslationImport() {
+    return t.importDeclaration([t.importSpecifier(t.identifier('useTranslation'), t.identifier('useTranslation'))], t.stringLiteral('react-i18next'));
+}
+function createTranslationHook() {
+    return t.variableDeclaration('const', [
+        t.variableDeclarator(t.objectPattern([t.objectProperty(t.identifier('t'), t.identifier('t'), false, true)]), t.callExpression(t.identifier('useTranslation'), [])),
+    ]);
+}
+function createTCall(key) {
+    return t.callExpression(t.identifier('t'), [t.stringLiteral(key)]);
+}
+function createJSXTCall(key) {
+    return t.jsxExpressionContainer(createTCall(key));
+}
+function extractJSXTextContent(node) {
+    const value = node.value;
+    return value.replace(/\s+/g, ' ').trim();
+}
+function getParentContext(path) {
+    let parent = path.parentPath;
+    while (parent && !parent.isJSXElement() && !parent.isJSXFragment()) {
+        parent = parent.parentPath;
+    }
+    if (!parent)
+        return null;
+    const children = parent.node.children;
+    if (!children || children.length < 2)
+        return null;
+    let textChildCount = 0;
+    let elementIndex = 0;
+    const parts = [];
+    for (const child of children) {
+        if (t.isJSXText(child)) {
+            const text = extractJSXTextContent(child);
+            if (text && text.length >= 2) {
+                textChildCount++;
+                parts.push(text);
+            }
+        }
+        else if (t.isJSXElement(child)) {
+            parts.push(`{#${elementIndex}}`);
+            elementIndex++;
+        }
+    }
+    if (textChildCount < 1 || (textChildCount < 2 && elementIndex < 1))
+        return null;
+    const parentContext = parts.join(' ').replace(/\s+/g, ' ').trim();
+    if (!parentContext)
+        return null;
+    let hash = 0;
+    for (let i = 0; i < parentContext.length; i++) {
+        const char = parentContext.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash;
+    }
+    return {
+        parentContext,
+        siblingGroupId: Math.abs(hash).toString(36),
+    };
+}
+function extractExpressionContent(node, variables = []) {
+    if (t.isStringLiteral(node))
+        return node.value;
+    if (t.isTemplateLiteral(node)) {
+        let result = '';
+        const quasis = node.quasis;
+        const expressions = node.expressions;
+        for (let i = 0; i < quasis.length; i++) {
+            result += quasis[i].value.raw;
+            if (i < expressions.length) {
+                const expr = expressions[i];
+                let varName = `var${variables.length}`;
+                if (t.isIdentifier(expr)) {
+                    varName = expr.name;
+                }
+                else if (t.isMemberExpression(expr) && t.isIdentifier(expr.property)) {
+                    varName = expr.property.name;
+                }
+                variables.push(varName);
+                result += `{${varName}}`;
+            }
+        }
+        return result;
+    }
+    if (t.isBinaryExpression(node) && node.operator === '+') {
+        const leftVars = [];
+        const rightVars = [];
+        const left = extractExpressionContent(node.left, leftVars);
+        const right = extractExpressionContent(node.right, rightVars);
+        if (left !== null && right !== null) {
+            variables.push(...leftVars, ...rightVars);
+            return left + right;
+        }
+        if (left !== null && t.isIdentifier(node.right)) {
+            const varName = node.right.name;
+            variables.push(...leftVars, varName);
+            return left + `{${varName}}`;
+        }
+        if (right !== null && t.isIdentifier(node.left)) {
+            const varName = node.left.name;
+            variables.push(varName, ...rightVars);
+            return `{${varName}}` + right;
+        }
+        if (left !== null && t.isMemberExpression(node.right) && t.isIdentifier(node.right.property)) {
+            const varName = node.right.property.name;
+            variables.push(...leftVars, varName);
+            return left + `{${varName}}`;
+        }
+        if (right !== null && t.isMemberExpression(node.left) && t.isIdentifier(node.left.property)) {
+            const varName = node.left.property.name;
+            variables.push(varName, ...rightVars);
+            return `{${varName}}` + right;
+        }
+        return null;
+    }
+    if (t.isJSXExpressionContainer(node)) {
+        return extractExpressionContent(node.expression, variables);
+    }
+    return null;
+}
+function extractConditionalContent(node) {
+    return {
+        consequent: extractExpressionContent(node.consequent),
+        alternate: extractExpressionContent(node.alternate),
+    };
+}
+/**
+ * Check if the file has a 'use client' directive
+ */
+function hasUseClientDirective(ast) {
+    if (ast.program.directives) {
+        for (const directive of ast.program.directives) {
+            if (directive.value && directive.value.value === 'use client') {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/utils/cache-keys.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Translation cache key helpers. The key format must stay identical to the
+ * backend's (config/redis CacheKeys.translation), which re-exports these so
+ * both sides read and write the same entries.
+ */
+export declare function hashText(text: string): string;
+export declare const TRANSLATION_CACHE_TTL_SECONDS: number;
+export declare function translationCacheKey(sourceLang: string, targetLang: string, textHash: string): string;

package/dist/utils/cache-keys.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRANSLATION_CACHE_TTL_SECONDS = void 0;
+exports.hashText = hashText;
+exports.translationCacheKey = translationCacheKey;
+const crypto_1 = require("crypto");
+/**
+ * Translation cache key helpers. The key format must stay identical to the
+ * backend's (config/redis CacheKeys.translation), which re-exports these so
+ * both sides read and write the same entries.
+ */
+function hashText(text) {
+    return (0, crypto_1.createHash)('sha256').update(text, 'utf8').digest('hex').slice(0, 16);
+}
+exports.TRANSLATION_CACHE_TTL_SECONDS = 30 * 24 * 60 * 60; // 30 days
+function translationCacheKey(sourceLang, targetLang, textHash) {
+    return `translation:${sourceLang}:${targetLang}:${textHash}`;
+}

package/dist/utils/circuit-breaker.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Circuit Breaker Pattern
+ *
+ * Prevents cascading failures by stopping requests to failing services
+ */
+export interface CircuitBreakerOptions {
+    failureThreshold: number;
+    resetTimeout: number;
+    halfOpenMaxCalls: number;
+}
+export declare enum CircuitState {
+    CLOSED = "closed",// Normal operation
+    OPEN = "open",// Failing, reject requests
+    HALF_OPEN = "half-open"
+}
+export declare class CircuitBreaker {
+    private name;
+    private options;
+    private state;
+    private failureCount;
+    private lastFailureTime;
+    private halfOpenCalls;
+    private successCount;
+    constructor(name: string, options?: CircuitBreakerOptions);
+    /**
+     * Execute a function with circuit breaker protection
+     */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    private onSuccess;
+    private onFailure;
+    getState(): CircuitState;
+    getStats(): {
+        name: string;
+        state: CircuitState;
+        failureCount: number;
+        lastFailureTime: number;
+    };
+    reset(): void;
+}
+/**
+ * Get or create a circuit breaker
+ */
+export declare function getCircuitBreaker(name: string, options?: CircuitBreakerOptions): CircuitBreaker;