@layr-labs/ecloud-sdk 0.2.1-dev → 0.2.2-dev

package/dist/helpers-CEvhJz7f.d.cts

@@ -0,0 +1,742 @@
+import { a6 as EnvironmentConfig, ag as SubscriptionStatus, a5 as BillingEnvironmentConfig, ae as ProductID, ai as CreateSubscriptionOptions, aj as CreateSubscriptionResponse, ar as ProductSubscriptionResponse, G as GasEstimate, ab as Logger } from './index-DeQzn_yM.cjs';
+import { Address, Hex, WalletClient, PublicClient, Chain } from 'viem';
+
+/**
+ * Environment configuration for different networks
+ */
+
+/**
+ * Get environment configuration
+ */
+declare function getEnvironmentConfig(environment: string, chainID?: bigint): EnvironmentConfig;
+/**
+ * Get billing environment configuration
+ * @param build - The build type ("dev" or "prod")
+ */
+declare function getBillingEnvironmentConfig(build: "dev" | "prod"): {
+    billingApiServerURL: string;
+};
+declare function getBuildType(): "dev" | "prod";
+/**
+ * Get available environments based on build type
+ * - dev: only "sepolia-dev"
+ * - prod: "sepolia" and "mainnet-alpha"
+ */
+declare function getAvailableEnvironments(): string[];
+/**
+ * Check if an environment is available in the current build
+ */
+declare function isEnvironmentAvailable(environment: string): boolean;
+/**
+ * Check if environment is mainnet (chain ID 1)
+ */
+declare function isMainnet(environmentConfig: EnvironmentConfig): boolean;
+
+/**
+ * Non-interactive validation utilities for SDK
+ *
+ * These functions validate parameters without any interactive prompts.
+ * They either return the validated value or throw an error.
+ */
+
+/**
+ * Validate app name format
+ * @throws Error if name is invalid
+ */
+declare function validateAppName(name: string): void;
+/**
+ * Validate Docker image reference format
+ * @returns true if valid, error message string if invalid
+ */
+declare function validateImageReference(value: string): true | string;
+/**
+ * Validate image reference and throw if invalid
+ * @throws Error if image reference is invalid
+ */
+declare function assertValidImageReference(value: string): void;
+/**
+ * Extract app name from image reference
+ */
+declare function extractAppNameFromImage(imageRef: string): string;
+/**
+ * Validate that a file path exists
+ * @returns true if valid, error message string if invalid
+ */
+declare function validateFilePath(value: string): true | string;
+/**
+ * Validate file path and throw if invalid
+ * @throws Error if file path is invalid or doesn't exist
+ */
+declare function assertValidFilePath(value: string): void;
+/**
+ * Validate instance type SKU against available types
+ * @returns the validated SKU
+ * @throws Error if SKU is not in the available types list
+ */
+declare function validateInstanceTypeSKU(sku: string, availableTypes: Array<{
+    sku: string;
+}>): string;
+/**
+ * Validate private key format
+ * Matches Go's common.ValidatePrivateKey() function
+ */
+declare function validatePrivateKeyFormat(key: string): boolean;
+/**
+ * Validate private key and throw if invalid
+ * @throws Error if private key format is invalid
+ */
+declare function assertValidPrivateKey(key: string): void;
+/**
+ * Validate URL format
+ * @returns undefined if valid, error message string if invalid
+ */
+declare function validateURL(rawURL: string): string | undefined;
+/**
+ * Validate X/Twitter URL format
+ * @returns undefined if valid, error message string if invalid
+ */
+declare function validateXURL(rawURL: string): string | undefined;
+/**
+ * Validate description length
+ * @returns undefined if valid, error message string if invalid
+ */
+declare function validateDescription(description: string): string | undefined;
+/**
+ * Validate image file path
+ * @returns undefined if valid, error message string if invalid
+ */
+declare function validateImagePath(filePath: string): string | undefined;
+/**
+ * Validate and normalize app ID address
+ * @param appID - App ID (must be a valid address)
+ * @returns Normalized app address
+ * @throws Error if app ID is not a valid address
+ *
+ * Note: Name resolution should be handled by CLI before calling SDK functions.
+ * The SDK only accepts resolved addresses.
+ */
+declare function validateAppID(appID: string | Address): Address;
+type LogVisibility = "public" | "private" | "off";
+/**
+ * Validate and convert log visibility setting to internal format
+ * @param logVisibility - Log visibility setting
+ * @returns Object with logRedirect and publicLogs settings
+ * @throws Error if log visibility value is invalid
+ */
+declare function validateLogVisibility(logVisibility: LogVisibility): {
+    logRedirect: string;
+    publicLogs: boolean;
+};
+type ResourceUsageMonitoring = "enable" | "disable";
+/**
+ * Validate and convert resource usage monitoring setting to internal format
+ * @param resourceUsageMonitoring - Resource usage monitoring setting
+ * @returns The resourceUsageAllow value for the Dockerfile label ("always" or "never")
+ * @throws Error if resource usage monitoring value is invalid
+ */
+declare function validateResourceUsageMonitoring(resourceUsageMonitoring: ResourceUsageMonitoring | undefined): string;
+/**
+ * Sanitize string (HTML escape and trim)
+ */
+declare function sanitizeString(s: string): string;
+/**
+ * Sanitize URL (add https:// if missing, validate)
+ * @throws Error if URL is invalid after sanitization
+ */
+declare function sanitizeURL(rawURL: string): string;
+/**
+ * Sanitize X/Twitter URL (handle username-only input, normalize)
+ * @throws Error if URL is invalid after sanitization
+ */
+declare function sanitizeXURL(rawURL: string): string;
+interface DeployParams {
+    dockerfilePath?: string;
+    imageRef?: string;
+    appName: string;
+    envFilePath?: string;
+    instanceType: string;
+    logVisibility: LogVisibility;
+}
+/**
+ * Validate deploy parameters
+ * @throws Error if required parameters are missing or invalid
+ */
+declare function validateDeployParams(params: Partial<DeployParams>): void;
+interface UpgradeParams {
+    appID: string | Address;
+    dockerfilePath?: string;
+    imageRef?: string;
+    envFilePath?: string;
+    instanceType: string;
+    logVisibility: LogVisibility;
+}
+/**
+ * Validate upgrade parameters
+ * @throws Error if required parameters are missing or invalid
+ */
+declare function validateUpgradeParams(params: Partial<UpgradeParams>): void;
+interface CreateAppParams {
+    name: string;
+    language: string;
+    template?: string;
+    templateVersion?: string;
+}
+/**
+ * Validate create app parameters
+ * @throws Error if required parameters are missing or invalid
+ */
+declare function validateCreateAppParams(params: Partial<CreateAppParams>): void;
+interface LogsParams {
+    appID: string | Address;
+    watch?: boolean;
+}
+/**
+ * Validate logs parameters
+ * @throws Error if required parameters are missing or invalid
+ */
+declare function validateLogsParams(params: Partial<LogsParams>): void;
+
+/**
+ * Billing utility functions
+ */
+
+/**
+ * Check if subscription status allows deploying apps
+ */
+declare function isSubscriptionActive(status: SubscriptionStatus): boolean;
+
+/**
+ * Private Key Generation
+ *
+ * Generate new secp256k1 private keys for Ethereum
+ */
+interface GeneratedKey {
+    privateKey: string;
+    address: string;
+}
+/**
+ * Generate a new secp256k1 private key
+ */
+declare function generateNewPrivateKey(): GeneratedKey;
+
+/**
+ * Compute API Session Management
+ *
+ * This module provides utilities for managing authentication sessions with the compute API
+ * using SIWE (Sign-In with Ethereum).
+ */
+
+interface ComputeApiConfig {
+    /** Base URL of the compute API (e.g., "https://api.eigencloud.xyz") */
+    baseUrl: string;
+}
+interface SessionInfo {
+    /** Whether the session is authenticated */
+    authenticated: boolean;
+    /** Authenticated wallet address (if authenticated) */
+    address?: Address;
+    /** Chain ID used for authentication (if authenticated) */
+    chainId?: number;
+}
+interface LoginResult {
+    /** Whether login was successful */
+    success: boolean;
+    /** Authenticated wallet address */
+    address: Address;
+}
+interface LoginRequest {
+    /** SIWE message string */
+    message: string;
+    /** Hex-encoded signature (with or without 0x prefix) */
+    signature: Hex | string;
+}
+/**
+ * Error thrown when session operations fail
+ */
+declare class SessionError extends Error {
+    readonly code: "NETWORK_ERROR" | "INVALID_SIGNATURE" | "INVALID_MESSAGE" | "SESSION_EXPIRED" | "UNAUTHORIZED" | "UNKNOWN";
+    readonly statusCode?: number | undefined;
+    constructor(message: string, code: "NETWORK_ERROR" | "INVALID_SIGNATURE" | "INVALID_MESSAGE" | "SESSION_EXPIRED" | "UNAUTHORIZED" | "UNKNOWN", statusCode?: number | undefined);
+}
+/**
+ * Login to the compute API using SIWE
+ *
+ * This establishes a session with the compute API by verifying the SIWE message
+ * and signature. On success, a session cookie is set in the browser.
+ *
+ * @param config - Compute API configuration
+ * @param request - Login request containing SIWE message and signature
+ * @returns Login result with the authenticated address
+ *
+ * @example
+ * ```typescript
+ * import { createSiweMessage, loginToComputeApi } from "@layr-labs/ecloud-sdk/browser";
+ *
+ * const { message } = createSiweMessage({
+ *   address: userAddress,
+ *   chainId: 11155111,
+ *   domain: window.location.host,
+ *   uri: window.location.origin,
+ * });
+ *
+ * const signature = await signMessageAsync({ message });
+ * const result = await loginToComputeApi(
+ *   { baseUrl: "https://api.eigencloud.xyz" },
+ *   { message, signature }
+ * );
+ * ```
+ */
+declare function loginToComputeApi(config: ComputeApiConfig, request: LoginRequest): Promise<LoginResult>;
+/**
+ * Get the current session status from the compute API
+ *
+ * @param config - Compute API configuration
+ * @returns Session information including authentication status and address
+ *
+ * @example
+ * ```typescript
+ * const session = await getComputeApiSession({ baseUrl: "https://api.eigencloud.xyz" });
+ * if (session.authenticated) {
+ *   console.log(`Logged in as ${session.address}`);
+ * }
+ * ```
+ */
+declare function getComputeApiSession(config: ComputeApiConfig): Promise<SessionInfo>;
+/**
+ * Logout from the compute API
+ *
+ * This destroys the current session and clears the session cookie.
+ *
+ * @param config - Compute API configuration
+ *
+ * @example
+ * ```typescript
+ * await logoutFromComputeApi({ baseUrl: "https://api.eigencloud.xyz" });
+ * ```
+ */
+declare function logoutFromComputeApi(config: ComputeApiConfig): Promise<void>;
+/**
+ * Check if a session is still valid (not expired)
+ *
+ * This is a convenience function that checks the session status
+ * and returns a boolean.
+ *
+ * @param config - Compute API configuration
+ * @returns True if session is authenticated, false otherwise
+ */
+declare function isSessionValid(config: ComputeApiConfig): Promise<boolean>;
+
+interface AppProfileInfo {
+    name: string;
+    website?: string;
+    description?: string;
+    xURL?: string;
+    imageURL?: string;
+}
+interface AppMetrics {
+    cpu_utilization_percent?: number;
+    memory_utilization_percent?: number;
+    memory_used_bytes?: number;
+    memory_total_bytes?: number;
+}
+interface DerivedAddress {
+    address: string;
+    derivationPath: string;
+}
+interface AppInfo {
+    address: Address;
+    status: string;
+    ip: string;
+    machineType: string;
+    profile?: AppProfileInfo;
+    metrics?: AppMetrics;
+    evmAddresses: DerivedAddress[];
+    solanaAddresses: DerivedAddress[];
+}
+interface AppInfoResponse {
+    apps: Array<{
+        addresses: {
+            data: {
+                evmAddresses: DerivedAddress[];
+                solanaAddresses: DerivedAddress[];
+            };
+            signature: string;
+        };
+        app_status: string;
+        ip: string;
+        machine_type: string;
+        profile?: AppProfileInfo;
+        metrics?: AppMetrics;
+    }>;
+}
+type AppContractStatus = "STARTED" | "STOPPED" | "TERMINATED" | "SUSPENDED" | string;
+interface AppReleaseBuild {
+    buildId?: string;
+    billingAddress?: string;
+    repoUrl?: string;
+    gitRef?: string;
+    status?: string;
+    buildType?: string;
+    imageName?: string;
+    imageDigest?: string;
+    imageUrl?: string;
+    provenanceJson?: unknown;
+    provenanceSignature?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    errorMessage?: string;
+    dependencies?: Record<string, AppReleaseBuild>;
+}
+interface AppRelease {
+    appId?: string;
+    rmsReleaseId?: string;
+    imageDigest?: string;
+    registryUrl?: string;
+    publicEnv?: string;
+    encryptedEnv?: string;
+    upgradeByTime?: number;
+    createdAt?: string;
+    createdAtBlock?: string;
+    build?: AppReleaseBuild;
+}
+interface AppResponse {
+    id: string;
+    creator?: string;
+    contractStatus?: AppContractStatus;
+    releases: AppRelease[];
+}
+/**
+ * Options for UserApiClient
+ */
+interface UserApiClientOptions {
+    /** Custom client ID for request tracking */
+    clientId?: string;
+    /**
+     * Use SIWE session authentication instead of per-request signatures.
+     * When true, requests rely on session cookies set by loginToComputeApi().
+     * When false (default), each request is signed individually.
+     */
+    useSession?: boolean;
+}
+/**
+ * UserAPI Client for interacting with the EigenCloud UserAPI service.
+ */
+declare class UserApiClient {
+    private readonly config;
+    private readonly walletClient;
+    private readonly publicClient;
+    private readonly clientId;
+    private readonly useSession;
+    constructor(config: EnvironmentConfig, walletClient: WalletClient, publicClient: PublicClient, options?: UserApiClientOptions);
+    /**
+     * Get the address of the connected wallet
+     */
+    get address(): Address;
+    getInfos(appIDs: Address[], addressCount?: number): Promise<AppInfo[]>;
+    /**
+     * Get app details from UserAPI (includes releases and build/provenance info when available).
+     *
+     * Endpoint: GET /apps/:appAddress
+     */
+    getApp(appAddress: Address): Promise<AppResponse>;
+    /**
+     * Get available SKUs (instance types) from UserAPI
+     */
+    getSKUs(): Promise<{
+        skus: Array<{
+            sku: string;
+            description: string;
+        }>;
+    }>;
+    /**
+     * Get logs for an app
+     */
+    getLogs(appID: Address): Promise<string>;
+    /**
+     * Get statuses for apps
+     */
+    getStatuses(appIDs: Address[]): Promise<Array<{
+        address: Address;
+        status: string;
+    }>>;
+    /**
+     * Upload app profile information with optional image
+     *
+     * @param appAddress - The app's contract address
+     * @param name - Display name for the app
+     * @param options - Optional fields including website, description, xURL, and image
+     * @param options.image - Image file as Blob or File (browser: from input element, Node.js: new Blob([buffer]))
+     * @param options.imageName - Filename for the image (required if image is provided)
+     */
+    uploadAppProfile(appAddress: Address, name: string, options?: {
+        website?: string;
+        description?: string;
+        xURL?: string;
+        image?: Blob | File;
+        imageName?: string;
+    }): Promise<{
+        name: string;
+        website?: string;
+        description?: string;
+        xURL?: string;
+        imageURL?: string;
+    }>;
+    private makeAuthenticatedRequest;
+    /**
+     * Generate authentication headers for UserAPI requests
+     */
+    private generateAuthHeaders;
+    /**
+     * Login to the compute API using SIWE (Sign-In with Ethereum)
+     *
+     * This establishes a session with the compute API by verifying the SIWE message
+     * and signature. On success, a session cookie is set in the browser.
+     *
+     * @param request - Login request containing SIWE message and signature
+     * @returns Login result with the authenticated address
+     *
+     * @example
+     * ```typescript
+     * import { createSiweMessage } from "@layr-labs/ecloud-sdk/browser";
+     *
+     * const { message } = createSiweMessage({
+     *   address: userAddress,
+     *   chainId: 11155111,
+     *   domain: window.location.host,
+     *   uri: window.location.origin,
+     * });
+     *
+     * const signature = await signMessageAsync({ message });
+     * const result = await client.siweLogin({ message, signature });
+     * ```
+     */
+    siweLogin(request: LoginRequest): Promise<LoginResult>;
+    /**
+     * Logout from the compute API
+     *
+     * This destroys the current session and clears the session cookie.
+     *
+     * @example
+     * ```typescript
+     * await client.siweLogout();
+     * ```
+     */
+    siweLogout(): Promise<void>;
+    /**
+     * Get the current SIWE session status from the compute API
+     *
+     * @returns Session information including authentication status and address
+     *
+     * @example
+     * ```typescript
+     * const session = await client.getSiweSession();
+     * if (session.authenticated) {
+     *   console.log(`Logged in as ${session.address}`);
+     * }
+     * ```
+     */
+    getSiweSession(): Promise<SessionInfo>;
+}
+
+/**
+ * BillingAPI Client to manage product subscriptions
+ * Standalone client - does not depend on chain infrastructure
+ *
+ * Accepts viem's WalletClient which abstracts over both local accounts
+ * (privateKeyToAccount) and external signers (MetaMask, etc.).
+ */
+
+/**
+ * BillingAPI Client for managing product subscriptions.
+ */
+declare class BillingApiClient {
+    private readonly config;
+    private readonly walletClient;
+    constructor(config: BillingEnvironmentConfig, walletClient: WalletClient);
+    /**
+     * Get the address of the connected wallet
+     */
+    get address(): Address;
+    createSubscription(productId?: ProductID, options?: CreateSubscriptionOptions): Promise<CreateSubscriptionResponse>;
+    getSubscription(productId?: ProductID): Promise<ProductSubscriptionResponse>;
+    cancelSubscription(productId?: ProductID): Promise<void>;
+    /**
+     * Make an authenticated request to the billing API
+     */
+    private makeAuthenticatedRequest;
+}
+
+/**
+ * EIP-7702 transaction handling
+ *
+ * This module handles EIP-7702 delegation and batch execution.
+ */
+
+type Execution = {
+    target: Address;
+    value: bigint;
+    callData: Hex;
+};
+/**
+ * Options for estimating batch gas
+ */
+interface EstimateBatchGasOptions {
+    publicClient: PublicClient;
+    account: Address;
+    executions: Execution[];
+}
+/**
+ * Estimate gas cost for a batch transaction
+ *
+ * Use this to get cost estimate before prompting user for confirmation.
+ */
+declare function estimateBatchGas(options: EstimateBatchGasOptions): Promise<GasEstimate>;
+interface ExecuteBatchOptions {
+    walletClient: WalletClient;
+    publicClient: PublicClient;
+    environmentConfig: EnvironmentConfig;
+    executions: Execution[];
+    pendingMessage: string;
+    /** Optional gas params from estimation */
+    gas?: GasEstimate;
+}
+/**
+ * Check if account is delegated to ERC-7702 delegator
+ */
+declare function checkERC7702Delegation(publicClient: PublicClient, account: Address, delegatorAddress: Address): Promise<boolean>;
+/**
+ * Execute batch of operations via EIP-7702 delegator
+ */
+declare function executeBatch(options: ExecuteBatchOptions, logger?: Logger): Promise<Hex>;
+
+/**
+ * SIWE (Sign-In with Ethereum) utilities for compute API authentication
+ *
+ * This module provides browser-safe utilities for creating and parsing SIWE messages
+ * compatible with the compute-tee API. Uses the official `siwe` package (EIP-4361).
+ */
+
+interface SiweMessageParams {
+    /** Ethereum address (checksummed or lowercase) */
+    address: Address;
+    /** Chain ID (e.g., 1 for mainnet, 11155111 for sepolia) */
+    chainId: number;
+    /** Domain requesting the signature (e.g., "api.eigencloud.xyz") */
+    domain: string;
+    /** Full URI of the signing request (e.g., "https://api.eigencloud.xyz") */
+    uri: string;
+    /** Optional nonce for replay protection (generated if not provided) */
+    nonce?: string;
+    /** Optional human-readable statement */
+    statement?: string;
+    /** Optional expiration time (defaults to 24 hours from now) */
+    expirationTime?: Date;
+    /** Optional issued at time (defaults to now) */
+    issuedAt?: Date;
+    /** Optional not-before time */
+    notBefore?: Date;
+    /** Optional request ID */
+    requestId?: string;
+    /** Optional resources array */
+    resources?: string[];
+}
+interface SiweMessageResult {
+    /** Raw SIWE message string for signing */
+    message: string;
+    /** Parsed parameters */
+    params: Required<Pick<SiweMessageParams, "address" | "chainId" | "domain" | "uri" | "nonce" | "issuedAt">> & Omit<SiweMessageParams, "address" | "chainId" | "domain" | "uri" | "nonce" | "issuedAt">;
+}
+/**
+ * Re-export generateNonce from siwe package
+ */
+declare const generateNonce: () => string;
+/**
+ * Create a SIWE message for compute API authentication
+ *
+ * @param params - Parameters for the SIWE message
+ * @returns The SIWE message object with the raw message string
+ *
+ * @example
+ * ```typescript
+ * const { message } = createSiweMessage({
+ *   address: "0x1234...",
+ *   chainId: 11155111,
+ *   domain: "api.eigencloud.xyz",
+ *   uri: "https://api.eigencloud.xyz",
+ *   statement: "Sign in to EigenCloud",
+ * });
+ *
+ * // Sign with wagmi
+ * const signature = await signMessageAsync({ message });
+ * ```
+ */
+declare function createSiweMessage(params: SiweMessageParams): SiweMessageResult;
+/**
+ * Parse a SIWE message string back to structured parameters
+ *
+ * @param message - Raw SIWE message string
+ * @returns Parsed parameters or null if invalid
+ */
+declare function parseSiweMessage(message: string): SiweMessageParams | null;
+/**
+ * Check if a SIWE message has expired
+ */
+declare function isSiweMessageExpired(params: SiweMessageParams): boolean;
+/**
+ * Check if a SIWE message is not yet valid (notBefore)
+ */
+declare function isSiweMessageNotYetValid(params: SiweMessageParams): boolean;
+
+/**
+ * General utility helpers
+ */
+
+/**
+ * Get a viem Chain object from a chain ID.
+ * Supports mainnet (1) and sepolia (11155111), defaults to the fallback chain for unknown chains.
+ */
+declare function getChainFromID(chainID: bigint, fallback?: Chain): Chain;
+/**
+ * Create viem clients from a private key
+ *
+ * This is a convenience helper for CLI and server applications that have direct
+ * access to a private key. For browser applications using external wallets (MetaMask, etc.),
+ * create the WalletClient directly using viem's createWalletClient with a custom transport.
+ *
+ * @example
+ * // CLI usage with private key
+ * const { walletClient, publicClient } = createClients({
+ *   privateKey: '0x...',
+ *   rpcUrl: 'https://sepolia.infura.io/v3/...',
+ *   chainId: 11155111n
+ * });
+ *
+ * @example
+ * // Browser usage with external wallet (create clients directly)
+ * const walletClient = createWalletClient({
+ *   chain: sepolia,
+ *   transport: custom(window.ethereum!)
+ * });
+ * const publicClient = createPublicClient({
+ *   chain: sepolia,
+ *   transport: custom(window.ethereum!)
+ * });
+ */
+declare function createClients(options: {
+    privateKey: string | Hex;
+    rpcUrl: string;
+    chainId: bigint;
+}): {
+    walletClient: WalletClient;
+    publicClient: PublicClient;
+};
+/**
+ * Ensure hex string has 0x prefix
+ */
+declare function addHexPrefix(value: string): Hex;
+/**
+ * Remove 0x prefix from hex string if present
+ */
+declare function stripHexPrefix(value: string): string;
+
+export { logoutFromComputeApi as $, type LogsParams as A, isSubscriptionActive as B, type ComputeApiConfig as C, generateNewPrivateKey as D, type UserApiClientOptions as E, type AppInfo as F, type GeneratedKey as G, type AppProfileInfo as H, type AppMetrics as I, type AppInfoResponse as J, BillingApiClient as K, type LogVisibility as L, estimateBatchGas as M, executeBatch as N, checkERC7702Delegation as O, type EstimateBatchGasOptions as P, type ExecuteBatchOptions as Q, type Execution as R, type SessionInfo as S, createSiweMessage as T, UserApiClient as U, parseSiweMessage as V, generateNonce as W, isSiweMessageExpired as X, isSiweMessageNotYetValid as Y, type SiweMessageResult as Z, loginToComputeApi as _, SessionError as a, getComputeApiSession as a0, isSessionValid as a1, type LoginResult as a2, type LoginRequest as a3, getChainFromID as a4, addHexPrefix as a5, stripHexPrefix as a6, type ResourceUsageMonitoring as a7, createClients as a8, type AppRelease as a9, type AppReleaseBuild as aa, type AppResponse as ab, validateFilePath as ac, assertValidFilePath as ad, validateImagePath as ae, validateResourceUsageMonitoring as af, type DeployParams as ag, validateDeployParams as ah, type UpgradeParams as ai, validateUpgradeParams as aj, type SiweMessageParams as b, getBillingEnvironmentConfig as c, getAvailableEnvironments as d, getBuildType as e, isMainnet as f, getEnvironmentConfig as g, validateImageReference as h, isEnvironmentAvailable as i, assertValidImageReference as j, extractAppNameFromImage as k, validateInstanceTypeSKU as l, validatePrivateKeyFormat as m, assertValidPrivateKey as n, validateURL as o, validateXURL as p, validateDescription as q, validateAppID as r, validateLogVisibility as s, sanitizeString as t, sanitizeURL as u, validateAppName as v, sanitizeXURL as w, validateCreateAppParams as x, validateLogsParams as y, type CreateAppParams as z };