lazysusan 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LazySusan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,164 @@
-# Temporary Holding Version
+# LazySusan SDK for JavaScript and TypeScript
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The official SDK for the [LazySusan API](https://www.lazysusan.ai/developers): chat, image and video models from every major AI lab through one API key and one prepaid balance. Switch models by changing one string.
+
+- Zero dependencies. Node 18+, Bun, Deno, edge runtimes.
+- Typed end to end.
+- Streaming, tool calling, images, async video, usage and cost on every response.
+
+Full reference: https://www.lazysusan.ai/developers/docs
+
+## Install
+
+```bash
+npm install https://www.lazysusan.ai/sdk/lazysusan-0.1.0.tgz
+```
+
+Get an API key in the [developer console](https://www.lazysusan.ai/developers/console) and set it as an environment variable:
+
+```bash
+export LAZYSUSAN_API_KEY=lsk_live_...
+```
+
+Keep keys on the server. Never ship them in browser or mobile code.
+
+## Chat
+
+```ts
+import LazySusan from 'lazysusan'
+
+const ls = new LazySusan() // reads LAZYSUSAN_API_KEY
+
+const reply = await ls.chat.create({
+  model: 'anthropic/claude-sonnet-5-5',
+  messages: [{ role: 'user', content: 'Summarise this in two lines: ...' }],
+})
+
+console.log(reply.text)
+console.log(reply.usage) // { inputTokens, outputTokens, totalTokens, costCredits }
+```
+
+### Switch models
+
+Every model takes the same request. Change the string and nothing else:
+
+```ts
+for (const model of ['anthropic/claude-opus-5-5', 'deepseek/deepseek-v4-pro', 'google/gemini-3.8-flash', 'xai/grok-4.7']) {
+  const r = await ls.chat.create({ model, messages: [{ role: 'user', content: 'One-line tagline for a coffee shop.' }] })
+  console.log(model, r.text, r.usage.costCredits)
+}
+```
+
+`await ls.models.list({ type: 'chat' })` returns every model with its price.
+
+### Stream
+
+```ts
+const stream = ls.chat.stream({
+  model: 'google/gemini-3.8-flash',
+  messages: [{ role: 'user', content: 'Write a haiku about deployments.' }],
+})
+
+for await (const event of stream) {
+  if (event.type === 'delta') process.stdout.write(event.text)
+  if (event.type === 'done') console.log('\ncredits:', event.usage?.costCredits)
+}
+```
+
+Or just `await stream.text()`. Call `stream.controller.abort()` to stop early.
+
+### Tools and JSON
+
+```ts
+const r = await ls.chat.create({
+  model: 'anthropic/claude-sonnet-5-5',
+  messages: [{ role: 'user', content: 'Weather in Paris?' }],
+  tools: [{ type: 'function', function: { name: 'get_weather', parameters: { type: 'object', properties: { city: { type: 'string' } } } } }],
+})
+console.log(r.toolCalls)
+```
+
+Pass `responseFormat: { type: 'json_object' }` for JSON output.
+
+## Images
+
+```ts
+const img = await ls.images.generate({
+  model: 'google/nano-banana-2.1',
+  prompt: 'A product photo of a ceramic mug on oak, soft daylight',
+  size: '1024x1024',
+})
+console.log(img.images[0].url)
+```
+
+## Video
+
+Videos run in the background. Start one, then wait for it:
+
+```ts
+const job = await ls.videos.create({ model: 'google/veo-3.1-fast', prompt: 'Slow pan across a misty lake at dawn', seconds: 8 })
+const video = await ls.videos.wait(job.id, { onProgress: (v) => console.log(v.status) })
+console.log(video.videoUrl)
+```
+
+Credits for a video are held when it starts and charged only if it succeeds. Failed videos are refunded.
+
+## Track usage by project
+
+Tag any request with `metadata` (up to 16 string pairs). Filter and group by these tags, by key, by team member, by model and by environment in the console.
+
+```ts
+await ls.chat.create({
+  model: 'anthropic/claude-haiku-5-5',
+  messages: [{ role: 'user', content: '...' }],
+  metadata: { project: 'support-bot', feature: 'triage', customer: 'acme' },
+})
+```
+
+Give each developer, service and environment its own key from the console for per-key budgets, model allowlists and expiry dates.
+
+## Errors
+
+Every failure throws a `LazySusanError` with `status`, `type`, `code`, `param` and `requestId`:
+
+```ts
+import LazySusan, { LazySusanError } from 'lazysusan'
+
+try {
+  await ls.chat.create({ model: 'anthropic/claude-fable-5-1', messages })
+} catch (e) {
+  if (LazySusanError.isInsufficientBalance(e)) {
+    // 402: the balance or a budget can't cover this request. Nothing was charged.
+    if (LazySusanError.isBudgetReached(e)) console.log('budget reached:', e.code)
+  } else if (LazySusanError.isPermission(e)) {
+    // 403: e.g. this key isn't allowed to use that model
+  } else if (LazySusanError.isRateLimit(e)) {
+    // 429 after automatic retries
+  }
+  console.error(e.requestId, e.message)
+}
+```
+
+The SDK retries automatically, with backoff, only where a retry can't cause a second charge:
+
+- `429` and `503` responses. These are never charged.
+- Network errors on `GET` requests.
+
+Other failures on `POST` requests are never retried. Configure retries with `new LazySusan({ maxRetries: 2, timeoutMs: 300000 })`.
+
+## Balance
+
+```ts
+const { balance } = await ls.credits.get() // credits; 1 credit = $0.001
+```
+
+## CommonJS
+
+```js
+const LazySusan = require('lazysusan')
+const ls = new LazySusan()
+```
+
+## License
+
+MIT

package/dist/cjs/index.cjs

@@ -0,0 +1,474 @@
+"use strict";
+/**
+ * LazySusan SDK — every leading AI model for chat, images and video through one API key.
+ * Docs: https://www.lazysusan.ai/developers/docs
+ *
+ * Zero dependencies. Runs on Node 18+, Deno, Bun, edge runtimes and modern browsers
+ * (anything with a global fetch). Never put an API key in code that ships to browsers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazySusan = exports.LazySusanError = exports.DEFAULT_BASE_URL = exports.VERSION = void 0;
+exports.VERSION = '0.1.0';
+exports.DEFAULT_BASE_URL = 'https://www.lazysusan.ai/api/v1';
+// ---------------------------------------------------------------------------------
+// Errors
+class LazySusanError extends Error {
+    constructor(message, opts = {}) {
+        super(message);
+        this.name = 'LazySusanError';
+        this.status = opts.status ?? 0;
+        this.type = opts.type ?? 'error';
+        this.code = opts.code ?? null;
+        this.param = opts.param ?? null;
+        this.requestId = opts.requestId ?? null;
+    }
+    /** The balance (or a monthly budget) can't cover the request. Nothing was charged. */
+    static isInsufficientBalance(e) {
+        return e instanceof LazySusanError && e.status === 402;
+    }
+    /** A key, team member or account budget was reached */
+    static isBudgetReached(e) {
+        return e instanceof LazySusanError && ['key_budget_reached', 'member_budget_reached', 'monthly_limit_reached'].includes(e.code ?? '');
+    }
+    static isAuthentication(e) {
+        return e instanceof LazySusanError && e.status === 401;
+    }
+    /** The key isn't allowed to do this (model allowlist, suspended member or account) */
+    static isPermission(e) {
+        return e instanceof LazySusanError && e.status === 403;
+    }
+    static isRateLimit(e) {
+        return e instanceof LazySusanError && e.status === 429;
+    }
+    static isInvalidRequest(e) {
+        return e instanceof LazySusanError && (e.status === 400 || e.status === 404 || e.status === 413);
+    }
+    static isTimeout(e) {
+        return e instanceof LazySusanError && e.code === 'timeout';
+    }
+}
+exports.LazySusanError = LazySusanError;
+// ---------------------------------------------------------------------------------
+// Helpers
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted)
+        return reject(abortError());
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener('abort', () => {
+        clearTimeout(t);
+        reject(abortError());
+    }, { once: true });
+});
+const abortError = () => new LazySusanError('The request was aborted.', { code: 'aborted', type: 'aborted' });
+/** Drop undefined values */
+function clean(o) {
+    const out = {};
+    for (const [k, v] of Object.entries(o))
+        if (v !== undefined)
+            out[k] = v;
+    return out;
+}
+function toUsage(u) {
+    return {
+        inputTokens: u?.prompt_tokens ?? 0,
+        outputTokens: u?.completion_tokens ?? 0,
+        totalTokens: u?.total_tokens ?? (u?.prompt_tokens ?? 0) + (u?.completion_tokens ?? 0),
+        ...(u?.prompt_tokens_details?.cached_tokens ? { cachedTokens: u.prompt_tokens_details.cached_tokens } : {}),
+        costCredits: u?.cost_credits ?? 0,
+    };
+}
+function toVideo(v, requestId) {
+    return clean({
+        id: v.id,
+        model: v.model,
+        status: v.status,
+        created: v.created,
+        completed: v.completed,
+        seconds: v.seconds,
+        resolution: v.resolution,
+        aspectRatio: v.aspect_ratio,
+        videoUrl: v.video_url,
+        error: v.error,
+        costCreditsHeld: v.cost_credits_held,
+        costCredits: v.cost_credits,
+        requestId,
+        raw: v,
+    });
+}
+function chatBody(p, stream) {
+    if (!p || typeof p.model !== 'string')
+        throw new LazySusanError('Set "model", e.g. "anthropic/claude-sonnet-5-5".', { type: 'invalid_request_error', param: 'model' });
+    if (!Array.isArray(p.messages) || p.messages.length === 0)
+        throw new LazySusanError('"messages" must be a non-empty array.', { type: 'invalid_request_error', param: 'messages' });
+    return clean({
+        model: p.model,
+        messages: p.messages,
+        max_tokens: p.maxTokens,
+        temperature: p.temperature,
+        top_p: p.topP,
+        presence_penalty: p.presencePenalty,
+        frequency_penalty: p.frequencyPenalty,
+        stop: p.stop,
+        seed: p.seed,
+        tools: p.tools,
+        tool_choice: p.toolChoice,
+        parallel_tool_calls: p.parallelToolCalls,
+        response_format: p.responseFormat,
+        metadata: p.metadata,
+        ...(stream ? { stream: true, stream_options: { include_usage: true } } : {}),
+    });
+}
+/** Status codes that are never charged and safe to retry on any method */
+const RETRYABLE_STATUS = new Set([429, 503]);
+// ---------------------------------------------------------------------------------
+// Client
+class LazySusan {
+    constructor(options = {}) {
+        const envKey = globalThis.process?.env?.LAZYSUSAN_API_KEY;
+        const apiKey = options.apiKey ?? envKey;
+        if (!apiKey) {
+            throw new LazySusanError('Missing API key. Pass { apiKey } or set LAZYSUSAN_API_KEY. Create a key at https://www.lazysusan.ai/developers/console.', { type: 'authentication_error', code: 'missing_api_key' });
+        }
+        this.apiKey = apiKey;
+        this.baseURL = (options.baseURL ?? exports.DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.timeoutMs = options.timeoutMs ?? 300000;
+        this.maxRetries = Math.max(0, options.maxRetries ?? 2);
+        const f = options.fetch ?? (typeof fetch !== 'undefined' ? fetch : undefined);
+        if (!f)
+            throw new LazySusanError('No fetch implementation available. Use Node 18+ or pass { fetch }.');
+        this.fetchImpl = f;
+        this.defaultHeaders = options.defaultHeaders ?? {};
+        this.chat = new Chat(this);
+        this.images = new Images(this);
+        this.videos = new Videos(this);
+        this.models = new Models(this);
+        this.credits = new Credits(this);
+    }
+    /** @internal Send a request with timeout and safe retries; returns the raw Response (ok) */
+    async _request(method, path, body, signal) {
+        let attempt = 0;
+        for (;;) {
+            const controller = new AbortController();
+            const onAbort = () => controller.abort();
+            signal?.addEventListener('abort', onAbort, { once: true });
+            const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+            let res;
+            try {
+                if (signal?.aborted)
+                    throw abortError();
+                res = await this.fetchImpl(`${this.baseURL}${path}`, {
+                    method,
+                    headers: {
+                        Authorization: `Bearer ${this.apiKey}`,
+                        Accept: 'application/json',
+                        'User-Agent': `lazysusan-js/${exports.VERSION}`,
+                        ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+                        ...this.defaultHeaders,
+                    },
+                    body: body !== undefined ? JSON.stringify(body) : undefined,
+                    signal: controller.signal,
+                });
+            }
+            catch (e) {
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', onAbort);
+                if (signal?.aborted)
+                    throw abortError();
+                const timedOut = controller.signal.aborted;
+                // A network failure on a POST may have reached the server: never retry it (could double-charge)
+                if (method === 'GET' && attempt < this.maxRetries) {
+                    await sleep(backoff(attempt++), signal);
+                    continue;
+                }
+                throw new LazySusanError(timedOut ? `The request timed out after ${this.timeoutMs} ms.` : `Network error: ${e?.message ?? e}`, { code: timedOut ? 'timeout' : 'network_error', type: 'connection_error' });
+            }
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            if (res.ok)
+                return res;
+            if (RETRYABLE_STATUS.has(res.status) && attempt < this.maxRetries) {
+                const retryAfter = Number(res.headers.get('retry-after'));
+                try {
+                    await res.body?.cancel();
+                }
+                catch { }
+                await sleep(Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter * 1000, 60000) : backoff(attempt), signal);
+                attempt++;
+                continue;
+            }
+            throw await toError(res);
+        }
+    }
+    /** @internal */
+    async _json(method, path, body, signal) {
+        const res = await this._request(method, path, body, signal);
+        const requestId = res.headers.get('x-request-id');
+        const text = await res.text();
+        try {
+            return { data: text ? JSON.parse(text) : {}, requestId };
+        }
+        catch {
+            throw new LazySusanError('The API returned a response that is not JSON.', { status: res.status, requestId });
+        }
+    }
+}
+exports.LazySusan = LazySusan;
+function backoff(attempt) {
+    const base = Math.min(500 * 2 ** attempt, 8000);
+    return base / 2 + Math.random() * (base / 2);
+}
+async function toError(res) {
+    const requestId = res.headers.get('x-request-id');
+    let body = null;
+    try {
+        body = await res.json();
+    }
+    catch { }
+    const e = body?.error ?? {};
+    return new LazySusanError(e.message || `Request failed with status ${res.status}.`, {
+        status: res.status,
+        type: e.type || 'api_error',
+        code: e.code ?? null,
+        param: e.param ?? null,
+        requestId,
+    });
+}
+// ---------------------------------------------------------------------------------
+// Chat
+class ChatStream {
+    constructor(client, params) {
+        this.client = client;
+        this.params = params;
+        this.consumed = false;
+        this.controller = new AbortController();
+        if (params.signal)
+            params.signal.addEventListener('abort', () => this.controller.abort(), { once: true });
+        this.iterator = this.run();
+    }
+    [Symbol.asyncIterator]() {
+        if (this.consumed)
+            throw new LazySusanError('A stream can only be read once.');
+        this.consumed = true;
+        return this.iterator;
+    }
+    /** Read the whole stream and return the full text */
+    async text() {
+        let final = '';
+        for await (const ev of this)
+            if (ev.type === 'done')
+                final = ev.text;
+        return final;
+    }
+    /** Read the whole stream and return the final event (text, usage, finish reason) */
+    async final() {
+        let last = null;
+        for await (const ev of this)
+            if (ev.type === 'done')
+                last = ev;
+        if (!last)
+            throw new LazySusanError('The stream ended without a final event.');
+        return last;
+    }
+    async *run() {
+        const res = await this.client._request('POST', '/chat/completions', chatBody(this.params, true), this.controller.signal);
+        const reader = res.body?.getReader();
+        if (!reader)
+            throw new LazySusanError('The API returned an empty stream.');
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let text = '';
+        let usage = null;
+        let finishReason = null;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let nl;
+                while ((nl = buffer.indexOf('\n')) >= 0) {
+                    const line = buffer.slice(0, nl).trim();
+                    buffer = buffer.slice(nl + 1);
+                    if (!line.startsWith('data:'))
+                        continue;
+                    const payload = line.slice(5).trim();
+                    if (!payload)
+                        continue;
+                    if (payload === '[DONE]') {
+                        yield { type: 'done', text, usage, finishReason };
+                        return;
+                    }
+                    let chunk;
+                    try {
+                        chunk = JSON.parse(payload);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (chunk?.error) {
+                        throw new LazySusanError(chunk.error.message || 'The stream was interrupted.', { type: chunk.error.type || 'api_error', code: chunk.error.code ?? null, requestId: res.headers.get('x-request-id') });
+                    }
+                    if (chunk?.usage)
+                        usage = toUsage(chunk.usage);
+                    const choice = chunk?.choices?.[0];
+                    if (!choice)
+                        continue;
+                    if (choice.finish_reason)
+                        finishReason = choice.finish_reason;
+                    const delta = choice.delta ?? {};
+                    const piece = typeof delta.content === 'string' ? delta.content : '';
+                    if (piece || delta.tool_calls) {
+                        text += piece;
+                        yield { type: 'delta', text: piece, ...(delta.tool_calls ? { toolCalls: delta.tool_calls } : {}), raw: chunk };
+                    }
+                }
+            }
+            // Stream closed without [DONE]
+            yield { type: 'done', text, usage, finishReason };
+        }
+        finally {
+            try {
+                reader.releaseLock();
+            }
+            catch { }
+        }
+    }
+}
+class Chat {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Send a chat request and wait for the full reply */
+    async create(params) {
+        const { data, requestId } = await this.client._json('POST', '/chat/completions', chatBody(params, false), params.signal);
+        const choice = data?.choices?.[0] ?? {};
+        const message = choice.message ?? { role: 'assistant', content: '' };
+        const text = typeof message.content === 'string' ? message.content : Array.isArray(message.content) ? message.content.map((p) => p?.text ?? '').join('') : '';
+        return {
+            id: data.id,
+            model: data.model,
+            text,
+            message,
+            finishReason: choice.finish_reason ?? null,
+            toolCalls: message.tool_calls ?? [],
+            usage: toUsage(data.usage),
+            ...(data.citations ? { citations: data.citations } : {}),
+            requestId,
+            raw: data,
+        };
+    }
+    /** Stream the reply as it's generated: `for await (const ev of ls.chat.stream({...}))` */
+    stream(params) {
+        return new ChatStream(this.client, params);
+    }
+}
+// ---------------------------------------------------------------------------------
+// Images
+class Images {
+    constructor(client) {
+        this.client = client;
+    }
+    async generate(params) {
+        const body = clean({
+            model: params.model,
+            prompt: params.prompt,
+            size: params.size,
+            quality: params.quality,
+            n: params.n,
+            image: params.image,
+            images: params.images,
+            response_format: params.format,
+            metadata: params.metadata,
+        });
+        const { data, requestId } = await this.client._json('POST', '/images/generations', body, params.signal);
+        return {
+            id: data.id,
+            model: data.model,
+            images: (data.data ?? []).map((d) => clean({ url: d.url, b64: d.b64_json, revisedPrompt: d.revised_prompt })),
+            usage: { images: data.usage?.images ?? 0, costCredits: data.usage?.cost_credits ?? 0 },
+            requestId,
+            raw: data,
+        };
+    }
+}
+// ---------------------------------------------------------------------------------
+// Videos
+class Videos {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Start a video. It runs in the background; poll with get() or use wait(). */
+    async create(params) {
+        const body = clean({
+            model: params.model,
+            prompt: params.prompt,
+            seconds: params.seconds,
+            resolution: params.resolution,
+            aspect_ratio: params.aspectRatio,
+            image: params.image,
+            negative_prompt: params.negativePrompt,
+            metadata: params.metadata,
+        });
+        const { data, requestId } = await this.client._json('POST', '/videos', body, params.signal);
+        return toVideo(data, requestId);
+    }
+    async get(id, options = {}) {
+        const { data, requestId } = await this.client._json('GET', `/videos/${encodeURIComponent(id)}`, undefined, options.signal);
+        return toVideo(data, requestId);
+    }
+    /** Your 50 most recent videos */
+    async list(options = {}) {
+        const { data, requestId } = await this.client._json('GET', '/videos', undefined, options.signal);
+        return (data.data ?? []).map((v) => toVideo(v, requestId));
+    }
+    /** Poll until the video is ready. Throws if it fails (failed videos are refunded) or the wait times out. */
+    async wait(id, options = {}) {
+        const interval = Math.max(2000, options.pollIntervalMs ?? 10000);
+        const deadline = Date.now() + (options.timeoutMs ?? 20 * 60000);
+        for (;;) {
+            const video = await this.get(id, { signal: options.signal });
+            options.onProgress?.(video);
+            if (video.status === 'succeeded')
+                return video;
+            if (video.status === 'failed') {
+                throw new LazySusanError(video.error?.message ?? 'The video could not be generated. You were not charged.', { type: 'video_failed', code: 'video_failed', requestId: video.requestId });
+            }
+            if (Date.now() + interval > deadline) {
+                throw new LazySusanError(`Still ${video.status} after waiting. Call videos.get("${id}") later; it keeps running.`, { code: 'timeout', type: 'timeout' });
+            }
+            await sleep(interval, options.signal);
+        }
+    }
+}
+// ---------------------------------------------------------------------------------
+// Models and credits
+class Models {
+    constructor(client) {
+        this.client = client;
+    }
+    async list(options = {}) {
+        const { data } = await this.client._json('GET', '/models', undefined, options.signal);
+        return (data.data ?? []).filter((m) => !options.type || m.type === options.type).map(toModel);
+    }
+    async get(id, options = {}) {
+        const path = id.split('/').map(encodeURIComponent).join('/');
+        const { data } = await this.client._json('GET', `/models/${path}`, undefined, options.signal);
+        return toModel(data);
+    }
+}
+function toModel(m) {
+    return { id: m.id, name: m.name, type: m.type, ownedBy: m.owned_by, description: m.description, pricing: m.pricing, raw: m };
+}
+class Credits {
+    constructor(client) {
+        this.client = client;
+    }
+    /** Remaining balance in credits (1 credit = $0.001) */
+    async get(options = {}) {
+        const { data } = await this.client._json('GET', '/credits', undefined, options.signal);
+        return { balance: data.balance, autoTopUp: !!data.auto_top_up };
+    }
+}
+exports.default = LazySusan;
+
+module.exports = Object.assign(exports.default, exports);