@closeloop/sdk 0.1.7 → 0.1.8

package/dist/nextjs.js

@@ -1,952 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/nextjs.ts
-var nextjs_exports = {};
-__export(nextjs_exports, {
-  AuthenticationError: () => AuthenticationError,
-  CloseLoop: () => CloseLoop,
-  CloseLoopError: () => CloseLoopError,
-  CreditsExpiredError: () => CreditsExpiredError,
-  InsufficientCreditsError: () => InsufficientCreditsError,
-  NetworkError: () => NetworkError,
-  NotFoundError: () => NotFoundError,
-  RateLimitError: () => RateLimitError,
-  ValidationError: () => ValidationError,
-  consumeCreditsAfterRequest: () => consumeCreditsAfterRequest,
-  creditGate: () => creditGate
-});
-module.exports = __toCommonJS(nextjs_exports);
-var import_server = require("next/server");
-
-// src/schemas/validation.ts
-var import_zod = require("zod");
-var walletAddressSchema = import_zod.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum wallet address");
-var planIdSchema = import_zod.z.string().min(1, "Plan ID is required").max(100, "Plan ID too long");
-var balanceIdSchema = import_zod.z.string().min(1, "Balance ID is required").max(100, "Balance ID too long");
-var creditAmountSchema = import_zod.z.number().int("Amount must be an integer").positive("Amount must be positive").max(1e9, "Amount exceeds maximum");
-var paginationLimitSchema = import_zod.z.number().int().positive().max(100, "Limit cannot exceed 100");
-var transactionTypeSchema = import_zod.z.enum([
-  "PURCHASE",
-  "CONSUMPTION",
-  "REFUND",
-  "EXPIRATION"
-]);
-var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function sanitizeMetadata(metadata) {
-  if (!metadata) return void 0;
-  const clean = /* @__PURE__ */ Object.create(null);
-  for (const [key, value] of Object.entries(metadata)) {
-    if (DANGEROUS_KEYS.has(key)) continue;
-    clean[key] = value;
-  }
-  return Object.freeze(clean);
-}
-var verifyCreditsSchema = import_zod.z.object({
-  walletAddress: walletAddressSchema,
-  planId: planIdSchema,
-  amount: creditAmountSchema
-});
-var consumeCreditsSchema = import_zod.z.object({
-  walletAddress: walletAddressSchema,
-  planId: planIdSchema,
-  amount: creditAmountSchema,
-  consumedBy: import_zod.z.string().max(100).optional(),
-  metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
-  idempotencyKey: import_zod.z.string().max(100).optional()
-});
-var batchConsumeSchema = import_zod.z.object({
-  operations: import_zod.z.array(
-    import_zod.z.object({
-      walletAddress: walletAddressSchema,
-      planId: planIdSchema,
-      amount: creditAmountSchema,
-      consumedBy: import_zod.z.string().max(100).optional(),
-      metadata: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional()
-    })
-  ).min(1, "At least one operation required").max(100, "Maximum 100 operations per batch"),
-  atomic: import_zod.z.boolean().optional()
-});
-var getBalanceSchema = import_zod.z.object({
-  walletAddress: walletAddressSchema,
-  planId: planIdSchema
-});
-var listBalancesSchema = import_zod.z.object({
-  walletAddress: walletAddressSchema,
-  activeOnly: import_zod.z.boolean().optional(),
-  limit: paginationLimitSchema.optional(),
-  cursor: import_zod.z.string().max(200).optional()
-});
-var listTransactionsSchema = import_zod.z.object({
-  balanceId: balanceIdSchema,
-  type: transactionTypeSchema.optional(),
-  limit: paginationLimitSchema.optional(),
-  cursor: import_zod.z.string().max(200).optional()
-});
-var webhookEventTypeSchema = import_zod.z.enum([
-  "payment.success",
-  "credits.low",
-  "credits.expired"
-]);
-var webhookEventSchema = import_zod.z.object({
-  type: webhookEventTypeSchema,
-  id: import_zod.z.string().min(1),
-  createdAt: import_zod.z.string(),
-  data: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())
-});
-var paymentSuccessPayloadSchema = import_zod.z.object({
-  type: import_zod.z.string(),
-  planId: import_zod.z.string(),
-  planName: import_zod.z.string(),
-  price: import_zod.z.number(),
-  walletAddress: import_zod.z.string(),
-  transactionId: import_zod.z.string()
-}).loose();
-var creditsLowPayloadSchema = import_zod.z.object({
-  walletAddress: import_zod.z.string(),
-  planId: import_zod.z.string(),
-  remainingCredits: import_zod.z.number(),
-  threshold: import_zod.z.number()
-});
-var creditsExpiredPayloadSchema = import_zod.z.object({
-  walletAddress: import_zod.z.string(),
-  planId: import_zod.z.string(),
-  expiredCredits: import_zod.z.number(),
-  expiresAt: import_zod.z.string()
-});
-
-// src/utils/errors.ts
-var CloseLoopError = class extends Error {
-  constructor(message, code, statusCode, details) {
-    super(message);
-    this.code = code;
-    this.statusCode = statusCode;
-    this.details = details;
-    this.name = "CloseLoopError";
-  }
-};
-var InsufficientCreditsError = class extends CloseLoopError {
-  constructor(remainingCredits, requiredCredits) {
-    super(
-      `Insufficient credits: ${remainingCredits} available, ${requiredCredits} required`,
-      "INSUFFICIENT_CREDITS",
-      402
-    );
-    this.remainingCredits = remainingCredits;
-    this.requiredCredits = requiredCredits;
-    this.name = "InsufficientCreditsError";
-  }
-};
-var CreditsExpiredError = class extends CloseLoopError {
-  constructor(expiresAt) {
-    super(
-      `Credits expired at ${expiresAt.toISOString()}`,
-      "CREDITS_EXPIRED",
-      410
-    );
-    this.expiresAt = expiresAt;
-    this.name = "CreditsExpiredError";
-  }
-};
-var AuthenticationError = class extends CloseLoopError {
-  constructor(message = "Invalid API key") {
-    super(message, "AUTHENTICATION_ERROR", 401);
-    this.name = "AuthenticationError";
-  }
-};
-var RateLimitError = class extends CloseLoopError {
-  constructor(retryAfter) {
-    super("Rate limit exceeded", "RATE_LIMIT", 429);
-    this.retryAfter = retryAfter;
-    this.name = "RateLimitError";
-  }
-};
-var NetworkError = class extends CloseLoopError {
-  constructor(message, cause) {
-    super(message, "NETWORK_ERROR");
-    this.cause = cause;
-    this.name = "NetworkError";
-  }
-};
-var NotFoundError = class extends CloseLoopError {
-  constructor(resource) {
-    super(`${resource} not found`, "NOT_FOUND", 404);
-    this.name = "NotFoundError";
-  }
-};
-var ValidationError = class extends CloseLoopError {
-  constructor(message, field) {
-    super(message, "VALIDATION_ERROR", 400);
-    this.field = field;
-    this.name = "ValidationError";
-  }
-};
-
-// src/constants.ts
-var DEFAULT_BASE_URL = "https://closeloop.app";
-var DEFAULT_TIMEOUT = 3e4;
-var SDK_VERSION = "0.1.0";
-var USER_AGENT = `closeloop-node/${SDK_VERSION}`;
-
-// src/utils/validation.ts
-function validateInput(schema, data) {
-  const result = schema.safeParse(data);
-  if (!result.success) {
-    throw new CloseLoopError(
-      `Validation error: ${result.error?.message || "Invalid input"}`,
-      "VALIDATION_ERROR",
-      400
-    );
-  }
-  return result.data;
-}
-
-// src/resources/balances.ts
-var ENDPOINTS = {
-  BALANCE: "/api/credit/balance",
-  BALANCES: "/api/credit/balances",
-  STATS: "/api/credit/stats"
-};
-var Balances = class {
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Get a specific credit balance for a wallet and plan.
-   *
-   * @example
-   * ```typescript
-   * const balance = await client.balances.get({
-   *   walletAddress: "0x1234...",
-   *   planId: "plan_abc123"
-   * })
-   *
-   * if (balance) {
-   *   console.log(`Credits: ${balance.remainingCredits}/${balance.totalCredits}`)
-   * }
-   * ```
-   *
-   * @returns The credit balance, or null if not found
-   * @throws {CloseLoopError} When input validation fails
-   */
-  async get(params) {
-    const validated = validateInput(getBalanceSchema, params);
-    const query = this.buildQueryString({
-      walletAddress: validated.walletAddress,
-      planId: validated.planId
-    });
-    try {
-      return await this.http.request({
-        method: "GET",
-        path: `${ENDPOINTS.BALANCE}?${query}`
-      });
-    } catch (error) {
-      if (error instanceof NotFoundError) {
-        return null;
-      }
-      throw error;
-    }
-  }
-  /**
-   * List all credit balances for a wallet.
-   *
-   * @example
-   * ```typescript
-   * const { balances, nextCursor } = await client.balances.list({
-   *   walletAddress: "0x1234...",
-   *   activeOnly: true,
-   *   limit: 10
-   * })
-   *
-   * for (const balance of balances) {
-   *   console.log(`${balance.planName}: ${balance.remainingCredits} credits`)
-   * }
-   *
-   * // Paginate if needed
-   * if (nextCursor) {
-   *   const nextPage = await client.balances.list({
-   *     walletAddress: "0x1234...",
-   *     cursor: nextCursor
-   *   })
-   * }
-   * ```
-   *
-   * @throws {CloseLoopError} When input validation fails
-   */
-  async list(params) {
-    const validated = validateInput(listBalancesSchema, params);
-    const query = this.buildQueryString({
-      walletAddress: validated.walletAddress,
-      activeOnly: validated.activeOnly,
-      limit: validated.limit,
-      cursor: validated.cursor
-    });
-    return this.http.request({
-      method: "GET",
-      path: `${ENDPOINTS.BALANCES}?${query}`
-    });
-  }
-  /**
-   * Get transaction history for a balance.
-   *
-   * @example
-   * ```typescript
-   * const { transactions } = await client.balances.transactions({
-   *   balanceId: "bal_xyz",
-   *   type: "CONSUMPTION",
-   *   limit: 50
-   * })
-   *
-   * for (const tx of transactions) {
-   *   console.log(`${tx.type}: ${tx.amount} - ${tx.description}`)
-   * }
-   * ```
-   *
-   * @throws {CloseLoopError} When input validation fails
-   */
-  async transactions(params) {
-    const validated = validateInput(listTransactionsSchema, params);
-    const query = this.buildQueryString({
-      type: validated.type,
-      limit: validated.limit,
-      cursor: validated.cursor
-    });
-    const basePath = `${ENDPOINTS.BALANCE}/${encodeURIComponent(validated.balanceId)}/transactions`;
-    const path = query ? `${basePath}?${query}` : basePath;
-    return this.http.request({
-      method: "GET",
-      path
-    });
-  }
-  /**
-   * Get aggregated stats for a wallet's credits.
-   *
-   * @example
-   * ```typescript
-   * const stats = await client.balances.stats("0x1234...")
-   * console.log(`Total: ${stats.totalCredits}, Used: ${stats.totalUsed}`)
-   * ```
-   *
-   * @throws {CloseLoopError} When input validation fails
-   */
-  async stats(walletAddress) {
-    validateInput(walletAddressSchema, walletAddress);
-    const query = this.buildQueryString({ walletAddress });
-    return this.http.request({
-      method: "GET",
-      path: `${ENDPOINTS.STATS}?${query}`
-    });
-  }
-  // ==========================================================================
-  // Private Helpers
-  // ==========================================================================
-  /**
-   * Build URL query string from params, filtering out undefined values
-   */
-  buildQueryString(params) {
-    const query = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-      if (value !== void 0) {
-        query.set(key, String(value));
-      }
-    }
-    return query.toString();
-  }
-};
-
-// src/resources/credits.ts
-var ENDPOINTS2 = {
-  VERIFY: "/api/credit/verify",
-  CONSUME: "/api/credit/consume",
-  BATCH_CONSUME: "/api/credit/consume/batch"
-};
-var Credits = class {
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Verify if a user has enough credits without consuming them.
-   *
-   * @example
-   * ```typescript
-   * const result = await client.credits.verify({
-   *   walletAddress: "0x1234...",
-   *   planId: "plan_abc123",
-   *   amount: 10
-   * })
-   *
-   * if (result.hasEnoughCredits) {
-   *   // Proceed with service
-   * }
-   * ```
-   *
-   * @throws {CloseLoopError} When input validation fails
-   */
-  async verify(params) {
-    const validated = validateInput(verifyCreditsSchema, params);
-    return this.http.request({
-      method: "POST",
-      path: ENDPOINTS2.VERIFY,
-      body: validated
-    });
-  }
-  /**
-   * Consume credits from a user's balance.
-   *
-   * @example
-   * ```typescript
-   * const result = await client.credits.consume({
-   *   walletAddress: "0x1234...",
-   *   planId: "plan_abc123",
-   *   amount: 1,
-   *   consumedBy: "ai-generation",
-   *   metadata: { requestId: "req_xyz" }
-   * })
-   *
-   * console.log(`Remaining: ${result.remainingCredits}`)
-   * ```
-   *
-   * @throws {InsufficientCreditsError} When user doesn't have enough credits
-   * @throws {CreditsExpiredError} When credits have expired
-   * @throws {CloseLoopError} When input validation fails
-   */
-  async consume(params) {
-    const validated = validateInput(consumeCreditsSchema, params);
-    return this.http.request({
-      method: "POST",
-      path: ENDPOINTS2.CONSUME,
-      body: this.buildConsumeBody(validated),
-      headers: this.buildIdempotencyHeaders(validated.idempotencyKey)
-    });
-  }
-  /**
-   * Verify and consume credits in a single atomic operation.
-   * This is useful when you want to ensure credits are available
-   * before consuming them, without race conditions.
-   *
-   * @example
-   * ```typescript
-   * try {
-   *   const result = await client.credits.verifyAndConsume({
-   *     walletAddress: "0x1234...",
-   *     planId: "plan_abc123",
-   *     amount: 5,
-   *     consumedBy: "batch-processing"
-   *   })
-   *   // Credits were verified and consumed
-   * } catch (error) {
-   *   if (error instanceof InsufficientCreditsError) {
-   *     // Handle insufficient credits
-   *   }
-   * }
-   * ```
-   *
-   * @throws {InsufficientCreditsError} When user doesn't have enough credits
-   * @throws {CreditsExpiredError} When credits have expired
-   * @throws {CloseLoopError} When input validation fails
-   */
-  async verifyAndConsume(params) {
-    const validated = validateInput(consumeCreditsSchema, params);
-    const verification = await this.http.request({
-      method: "POST",
-      path: ENDPOINTS2.VERIFY,
-      body: {
-        walletAddress: validated.walletAddress,
-        planId: validated.planId,
-        amount: validated.amount
-      }
-    });
-    this.assertCreditsAvailable(verification, validated.amount);
-    return this.http.request({
-      method: "POST",
-      path: ENDPOINTS2.CONSUME,
-      body: this.buildConsumeBody(validated),
-      headers: this.buildIdempotencyHeaders(validated.idempotencyKey)
-    });
-  }
-  /**
-   * Consume credits in batch.
-   *
-   * @example
-   * ```typescript
-   * const result = await client.credits.batchConsume({
-   *   operations: [
-   *     { walletAddress: "0x1234...", planId: "plan_a", amount: 1 },
-   *     { walletAddress: "0x5678...", planId: "plan_b", amount: 2 }
-   *   ],
-   *   atomic: false // Allow partial success
-   * })
-   *
-   * console.log(`Success: ${result.successCount}, Failed: ${result.failedCount}`)
-   * ```
-   *
-   * @throws {CloseLoopError} When input validation fails
-   */
-  async batchConsume(params) {
-    const validated = validateInput(batchConsumeSchema, params);
-    const sanitizedOperations = validated.operations.map((op) => ({
-      ...op,
-      metadata: sanitizeMetadata(op.metadata)
-    }));
-    return this.http.request({
-      method: "POST",
-      path: ENDPOINTS2.BATCH_CONSUME,
-      body: {
-        operations: sanitizedOperations,
-        atomic: validated.atomic
-      }
-    });
-  }
-  // ==========================================================================
-  // Private Helpers
-  // ==========================================================================
-  /**
-   * Build consumption request body with sanitized metadata
-   */
-  buildConsumeBody(validated) {
-    return {
-      walletAddress: validated.walletAddress,
-      planId: validated.planId,
-      amount: validated.amount,
-      consumedBy: validated.consumedBy,
-      metadata: sanitizeMetadata(validated.metadata)
-    };
-  }
-  /**
-   * Build idempotency headers if key is provided
-   */
-  buildIdempotencyHeaders(idempotencyKey) {
-    if (!idempotencyKey) return {};
-    return { "Idempotency-Key": idempotencyKey };
-  }
-  /**
-   * Assert credits are available, throw typed errors if not
-   */
-  assertCreditsAvailable(verification, requiredAmount) {
-    if (!verification.hasEnoughCredits) {
-      throw new InsufficientCreditsError(
-        verification.remainingCredits,
-        requiredAmount
-      );
-    }
-    if (verification.expiresAt) {
-      const expirationDate = new Date(verification.expiresAt);
-      if (expirationDate < /* @__PURE__ */ new Date()) {
-        throw new CreditsExpiredError(expirationDate);
-      }
-    }
-  }
-};
-
-// src/utils/crypto.ts
-var import_crypto = require("crypto");
-function generateSignature(payload, secret) {
-  return (0, import_crypto.createHmac)("sha256", secret).update(payload).digest("hex");
-}
-function verifySignature(payload, signature, secret) {
-  const expectedSignature = generateSignature(payload, secret);
-  if (signature.length !== expectedSignature.length) {
-    return false;
-  }
-  return (0, import_crypto.timingSafeEqual)(Buffer.from(signature), Buffer.from(expectedSignature));
-}
-
-// src/resources/webhooks.ts
-var ERROR_CODES = {
-  VALIDATION: "VALIDATION_ERROR",
-  INVALID_SIGNATURE: "INVALID_SIGNATURE",
-  INVALID_PAYLOAD: "INVALID_PAYLOAD"
-};
-var Webhooks = class {
-  /**
-   * Verify a webhook signature and parse the event.
-   *
-   * @example
-   * ```typescript
-   * // Express handler
-   * app.post("/webhook", (req, res) => {
-   *   try {
-   *     const event = client.webhooks.verify({
-   *       payload: req.body,
-   *       signature: req.headers["x-closeloop-signature"],
-   *       secret: process.env.WEBHOOK_SECRET!
-   *     })
-   *
-   *     if (client.webhooks.isPaymentSuccess(event)) {
-   *       const { type, walletAddress, planId, amount } = event.data
-   *       // Handle payment success
-   *     }
-   *
-   *     res.json({ received: true })
-   *   } catch (error) {
-   *     res.status(400).json({ error: "Invalid signature" })
-   *   }
-   * })
-   * ```
-   *
-   * @example
-   * ```typescript
-   * // Next.js App Router
-   * export async function POST(request: Request) {
-   *   const payload = await request.text()
-   *   const signature = request.headers.get("x-closeloop-signature")!
-   *
-   *   const event = client.webhooks.verify({
-   *     payload,
-   *     signature,
-   *     secret: process.env.WEBHOOK_SECRET!
-   *   })
-   *
-   *   // Handle event...
-   *   return Response.json({ received: true })
-   * }
-   * ```
-   *
-   * @throws {CloseLoopError} When signature is invalid or payload is malformed
-   */
-  verify(params) {
-    this.validateRequiredParams(params);
-    const payloadString = this.normalizePayload(params.payload);
-    this.verifySignatureOrThrow(payloadString, params.signature, params.secret);
-    const parsed = this.parseJsonOrThrow(payloadString);
-    return this.validateEventStructure(parsed);
-  }
-  /**
-   * Type guard for payment.success events
-   * Also validates the payload structure
-   *
-   * @example
-   * ```typescript
-   * if (client.webhooks.isPaymentSuccess(event)) {
-   *   // TypeScript knows event.data is PaymentSuccessPayload
-   *   console.log(event.data.planId, event.data.walletAddress)
-   * }
-   * ```
-   */
-  isPaymentSuccess(event) {
-    return event.type === "payment.success" && paymentSuccessPayloadSchema.safeParse(event.data).success;
-  }
-  /**
-   * Type guard for credits.low events
-   * Also validates the payload structure
-   *
-   * @example
-   * ```typescript
-   * if (client.webhooks.isCreditsLow(event)) {
-   *   // TypeScript knows event.data is CreditsLowPayload
-   *   console.log(`Low balance: ${event.data.remainingCredits}`)
-   * }
-   * ```
-   */
-  isCreditsLow(event) {
-    return event.type === "credits.low" && creditsLowPayloadSchema.safeParse(event.data).success;
-  }
-  /**
-   * Type guard for credits.expired events
-   * Also validates the payload structure
-   *
-   * @example
-   * ```typescript
-   * if (client.webhooks.isCreditsExpired(event)) {
-   *   // TypeScript knows event.data is CreditsExpiredPayload
-   *   console.log(`Expired: ${event.data.expiredCredits} credits`)
-   * }
-   * ```
-   */
-  isCreditsExpired(event) {
-    return event.type === "credits.expired" && creditsExpiredPayloadSchema.safeParse(event.data).success;
-  }
-  // ==========================================================================
-  // Private Helpers
-  // ==========================================================================
-  /**
-   * Validate that all required parameters are present
-   */
-  validateRequiredParams(params) {
-    if (!params.payload) {
-      throw new CloseLoopError(
-        "Webhook payload is required",
-        ERROR_CODES.VALIDATION,
-        400
-      );
-    }
-    if (!params.signature) {
-      throw new CloseLoopError(
-        "Webhook signature is required",
-        ERROR_CODES.VALIDATION,
-        400
-      );
-    }
-    if (!params.secret) {
-      throw new CloseLoopError(
-        "Webhook secret is required",
-        ERROR_CODES.VALIDATION,
-        400
-      );
-    }
-  }
-  /**
-   * Convert payload to string regardless of input type
-   */
-  normalizePayload(payload) {
-    return typeof payload === "string" ? payload : payload.toString("utf8");
-  }
-  /**
-   * Verify HMAC signature or throw error
-   */
-  verifySignatureOrThrow(payload, signature, secret) {
-    if (!verifySignature(payload, signature, secret)) {
-      throw new CloseLoopError(
-        "Invalid webhook signature",
-        ERROR_CODES.INVALID_SIGNATURE,
-        401
-      );
-    }
-  }
-  /**
-   * Parse JSON payload or throw error
-   */
-  parseJsonOrThrow(payload) {
-    try {
-      return JSON.parse(payload);
-    } catch {
-      throw new CloseLoopError(
-        "Invalid webhook payload: could not parse JSON",
-        ERROR_CODES.INVALID_PAYLOAD,
-        400
-      );
-    }
-  }
-  /**
-   * Validate event structure using Zod schema
-   */
-  validateEventStructure(parsed) {
-    const result = webhookEventSchema.safeParse(parsed);
-    if (!result.success) {
-      throw new CloseLoopError(
-        "Invalid webhook payload structure",
-        ERROR_CODES.INVALID_PAYLOAD,
-        400
-      );
-    }
-    return result.data;
-  }
-};
-
-// src/utils/http.ts
-var HttpClient = class {
-  baseUrl;
-  apiKey;
-  timeout;
-  constructor(options) {
-    this.baseUrl = options.baseUrl.replace(/\/$/, "");
-    this.apiKey = options.apiKey;
-    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
-  }
-  /**
-   * Make an HTTP request to the CloseLoop API
-   */
-  async request(options) {
-    const url = `${this.baseUrl}${options.path}`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch(url, {
-        method: options.method,
-        headers: {
-          "Content-Type": "application/json",
-          "User-Agent": USER_AGENT,
-          Authorization: `Bearer ${this.apiKey}`,
-          ...options.headers
-        },
-        body: options.body ? JSON.stringify(options.body) : void 0,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        await this.handleErrorResponse(response);
-      }
-      if (response.status === 204) {
-        return {};
-      }
-      return await response.json();
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof CloseLoopError) {
-        throw error;
-      }
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new NetworkError("Request timeout");
-      }
-      throw new NetworkError(
-        error instanceof Error ? error.message : "Network request failed",
-        error instanceof Error ? error : void 0
-      );
-    }
-  }
-  async handleErrorResponse(response) {
-    let errorData = {};
-    try {
-      const json = await response.json();
-      errorData = json;
-    } catch {
-    }
-    const message = errorData.message || `Request failed with status ${response.status}`;
-    switch (response.status) {
-      case 401:
-        throw new AuthenticationError(message);
-      case 404:
-        throw new NotFoundError(message);
-      case 429: {
-        const retryAfter = response.headers.get("Retry-After");
-        throw new RateLimitError(
-          retryAfter ? parseInt(retryAfter, 10) : void 0
-        );
-      }
-      default:
-        throw new CloseLoopError(
-          message,
-          errorData.code || "API_ERROR",
-          response.status,
-          errorData.details
-        );
-    }
-  }
-};
-
-// src/client.ts
-var CloseLoop = class {
-  httpClient;
-  /**
-   * Credit consumption and verification operations
-   */
-  credits;
-  /**
-   * Credit balance queries
-   */
-  balances;
-  /**
-   * Webhook signature verification utilities
-   */
-  webhooks;
-  constructor(options) {
-    if (!options.apiKey) {
-      throw new Error("CloseLoop API key is required");
-    }
-    const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
-    this.httpClient = new HttpClient({
-      baseUrl,
-      apiKey: options.apiKey,
-      timeout: options.timeout
-    });
-    this.credits = new Credits(this.httpClient);
-    this.balances = new Balances(this.httpClient);
-    this.webhooks = new Webhooks();
-  }
-};
-
-// src/nextjs.ts
-function errorResponse(error, status, extra) {
-  return import_server.NextResponse.json({ error, ...extra }, { status });
-}
-function handleCreditError(error) {
-  if (error instanceof InsufficientCreditsError) {
-    return errorResponse("Insufficient credits", 402, {
-      required: error.requiredCredits,
-      remaining: error.remainingCredits
-    });
-  }
-  if (error instanceof CreditsExpiredError) {
-    return errorResponse("Credits expired", 410, {
-      expiredAt: error.expiresAt.toISOString()
-    });
-  }
-  if (error instanceof CloseLoopError) {
-    return errorResponse(error.message, error.statusCode || 500);
-  }
-  return null;
-}
-function creditGate(options) {
-  validateOptions(options);
-  const creditsRequired = options.creditsPerRequest ?? 1;
-  return async function middleware(request) {
-    const walletAddress = await options.getWalletAddress(request);
-    if (!walletAddress) {
-      return errorResponse("Wallet address required", 401);
-    }
-    if (!walletAddressSchema.safeParse(walletAddress).success) {
-      return errorResponse("Invalid wallet address format", 400);
-    }
-    try {
-      const verification = await options.client.credits.verify({
-        walletAddress,
-        planId: options.planId,
-        amount: creditsRequired
-      });
-      if (!verification.hasEnoughCredits) {
-        return errorResponse("Insufficient credits", 402, {
-          required: creditsRequired,
-          remaining: verification.remainingCredits
-        });
-      }
-      return createSuccessResponse(verification);
-    } catch (error) {
-      const handledResponse = handleCreditError(error);
-      if (handledResponse) return handledResponse;
-      throw error;
-    }
-  };
-}
-function validateOptions(options) {
-  if (!options.planId?.length) {
-    throw new Error("creditGate: planId is required");
-  }
-  if (!options.client) {
-    throw new Error("creditGate: CloseLoop client is required");
-  }
-  if (!options.getWalletAddress) {
-    throw new Error("creditGate: getWalletAddress function is required");
-  }
-}
-function createSuccessResponse(verification) {
-  const response = import_server.NextResponse.next();
-  response.headers.set(
-    "X-Credits-Remaining",
-    String(verification.remainingCredits)
-  );
-  return response;
-}
-async function consumeCreditsAfterRequest(client, params) {
-  await client.credits.consume(params);
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AuthenticationError,
-  CloseLoop,
-  CloseLoopError,
-  CreditsExpiredError,
-  InsufficientCreditsError,
-  NetworkError,
-  NotFoundError,
-  RateLimitError,
-  ValidationError,
-  consumeCreditsAfterRequest,
-  creditGate
-});
-//# sourceMappingURL=nextjs.js.map