@omnibase/core-js 0.8.0 → 0.9.0

package/dist/payments/index.d.cts

@@ -1,3287 +0,0 @@
-import { RelationshipApi, PermissionApi } from '@ory/client';
-
-/**
- * Base API Response structure for all operations
- *
- * This generic type defines the standard response format returned by all
- * API endpoints. It provides a consistent structure for
- * handling both successful responses and error conditions across the SDK.
- *
- * @template T - The type of the response data payload
- *
- * @example
- * Successful response:
- * ```typescript
- * const response: ApiResponse<{ tenant: Tenant }> = {
- *   data: { tenant: { id: '123', name: 'My Company' } },
- *   status: 200
- * };
- * ```
- *
- * @example
- * Error response:
- * ```typescript
- * const response: ApiResponse<never> = {
- *   status: 400,
- *   error: 'Invalid tenant name provided'
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- */
-type ApiResponse<T> = {
-    /**
-     * Response data payload (present only on successful operations)
-     * Contains the actual data returned by the API endpoint
-     */
-    data?: T;
-    /**
-     * HTTP status code indicating the result of the operation
-     * @example 200 for success, 400 for client errors, 500 for server errors
-     */
-    status: number;
-    /**
-     * Error message (present only when operation fails)
-     * Provides human-readable description of what went wrong
-     */
-    error?: string;
-};
-
-/**
- * Configuration options for creating a Stripe checkout session
- *
- * Defines all parameters needed to create a checkout session for either
- * one-time payments or subscription billing. The checkout mode (payment vs
- * subscription) is automatically determined by examining the price configuration
- * - no need to specify it manually.
- *
- * @example
- * ```typescript
- * const options: CheckoutOptions = {
- *   price_id: 'price_monthly_pro',
- *   success_url: 'https://app.com/success?session_id={CHECKOUT_SESSION_ID}',
- *   cancel_url: 'https://app.com/pricing',
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Checkout
- */
-type CheckoutOptions = {
-    /** Stripe price ID for the product/service being purchased */
-    price_id: string;
-    /**
-     * URL to redirect to after successful payment
-     * Can include {CHECKOUT_SESSION_ID} placeholder for session tracking
-     */
-    success_url: string;
-    /** URL to redirect to if the user cancels the checkout */
-    cancel_url: string;
-    /**
-     * Number of days for the trial period (subscriptions only)
-     * Only applies when the price has a recurring interval
-     */
-    trial_period_days?: number;
-    /**
-     * Stripe promotion code ID to apply automatically
-     * Mutually exclusive with allow_promotion_codes
-     */
-    promotion_code?: string;
-    /**
-     * Whether to show promotion code input field in checkout
-     * Allows customers to enter their own promo codes
-     */
-    allow_promotion_codes?: boolean;
-};
-/**
- * Response from creating a checkout session
- *
- * Contains the checkout session URL and ID for redirecting users
- * to Stripe's hosted checkout page and tracking the session.
- *
- * @since 0.6.0
- * @public
- * @group Checkout
- */
-type CreateCheckoutResponse = ApiResponse<{
-    /** URL to redirect the user to for completing payment */
-    url: string;
-    /** Unique identifier for the checkout session */
-    sessionId: string;
-}>;
-/**
- * Manager for Stripe checkout session operations
- *
- * Handles creation and management of Stripe checkout sessions for both
- * one-time payments and subscription billing. The checkout mode is automatically
- * determined by examining whether the price has a recurring interval - recurring
- * prices create subscription checkouts, while non-recurring prices create one-time
- * payment checkouts.
- *
- * Checkout sessions provide a secure, PCI-compliant payment flow without requiring
- * sensitive payment data to touch your servers. The API automatically fetches the
- * price details from Stripe to determine the appropriate checkout mode.
- *
- * @example
- * ```typescript
- * const checkoutManager = new CheckoutManager(omnibaseClient);
- *
- * const session = await checkoutManager.createSession({
- *   price_id: 'price_monthly_pro',
- *   success_url: 'https://app.com/welcome?session_id={CHECKOUT_SESSION_ID}',
- *   cancel_url: 'https://app.com/pricing',
- * });
- *
- * // Redirect user to checkout
- * window.location.href = session.data.url;
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Checkout
- */
-declare class CheckoutManager {
-    private omnibaseClient;
-    /**
-     * Initialize the checkout manager
-     *
-     * @param paymentHandler - Payment handler instance for API communication
-     *
-     * @group Checkout
-     */
-    constructor(omnibaseClient: OmnibaseClient);
-    /**
-     * Create a new Stripe checkout session
-     *
-     * Creates a checkout session with the specified options and returns
-     * the session URL for redirecting the user to complete payment.
-     * The checkout mode (one-time payment or subscription) is automatically
-     * determined from the price's configuration - no need to specify it manually.
-     *
-     * @param options - Configuration options for the checkout session
-     * @param options.price_id - Stripe price ID for the product/service
-     * @param options.success_url - URL to redirect after successful payment
-     * @param options.cancel_url - URL to redirect if user cancels
-     *
-     * @returns Promise resolving to checkout session response with URL and session ID
-     *
-     * @throws {Error} When the API request fails due to network issues
-     * @throws {Error} When the server returns an error response (invalid price_id, etc.)
-     * @throws {ValidationError} When required parameters are missing or invalid
-     *
-     * @example
-     * ```typescript
-     * const session = await checkoutManager.createSession({
-     *   price_id: 'price_monthly_pro',
-     *   success_url: 'https://app.com/success',
-     *   cancel_url: 'https://app.com/cancel'
-     * });
-     *
-     * // Redirect to Stripe checkout
-     * if (session.data?.url) {
-     *   window.location.href = session.data.url;
-     * }
-     * ```
-     *
-     * @since 0.6.0
-     * @group Checkout
-     */
-    createSession(options: CheckoutOptions): Promise<CreateCheckoutResponse>;
-}
-
-/**
- * Response from Stripe configuration API endpoints
- *
- * Contains the current Stripe configuration including products, prices,
- * and UI customization settings. This represents the complete billing
- * configuration loaded from the database.
- *
- * @since 0.6.0
- * @public
- * @group Configuration
- */
-type StripeConfigResponse = ApiResponse<{
-    /** The complete Stripe configuration object */
-    config: StripeConfiguration;
-    /** Optional message from the API response */
-    message?: string;
-}>;
-/**
- * Complete Stripe billing configuration
- *
- * Represents a versioned Stripe configuration containing all products,
- * prices, and UI customizations. This configuration is stored in the
- * database and enables safe deployment and rollback of pricing changes.
- *
- * @example
- * ```typescript
- * const config: StripeConfiguration = {
- *   version: "v1.2.0",
- *   products: [
- *     {
- *       id: "starter_plan",
- *       name: "Starter Plan",
- *       description: "Perfect for individuals and small teams",
- *       type: "service",
- *       prices: [...]
- *     }
- *   ]
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Configuration
- */
-interface StripeConfiguration {
-    /** Version identifier for this configuration */
-    version: string;
-    /** Array of all products in this configuration */
-    products: Product[];
-}
-/**
- * Product definition in Stripe configuration
- *
- * Represents a billable product or service with associated pricing options
- * and UI customizations. Products can be services, physical goods, or
- * metered usage products.
- *
- * @example
- * ```typescript
- * const product: Product = {
- *   id: "pro_plan",
- *   name: "Professional Plan",
- *   description: "Advanced features for growing businesses",
- *   type: "service",
- *   prices: [
- *     { id: "monthly", amount: 2900, currency: "usd", interval: "month" },
- *     { id: "yearly", amount: 29000, currency: "usd", interval: "year" }
- *   ],
- *   ui: {
- *     display_name: "Pro",
- *     tagline: "Most Popular",
- *     features: ["Unlimited projects", "24/7 support"],
- *     highlighted: true
- *   }
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Configuration
- */
-interface Product {
-    /** Unique identifier for this product */
-    id: string;
-    /** Display name for the product */
-    name: string;
-    /** Optional detailed description */
-    description?: string;
-    /**
-     * Product type affecting billing behavior
-     * - 'service': Subscription services
-     * - 'good': Physical or digital goods
-     * - 'metered': Usage-based billing
-     */
-    type?: "service" | "good" | "metered";
-    /** Array of pricing options for this product */
-    prices: Price[];
-    /** Optional UI customization settings */
-    ui?: ProductUI;
-}
-/**
- * Price definition for a product
- *
- * Defines a specific pricing option including amount, currency, billing
- * frequency, and advanced pricing features like tiered billing. Supports
- * both fixed and usage-based pricing models.
- *
- * @example
- * Simple monthly pricing:
- * ```typescript
- * const monthlyPrice: Price = {
- *   id: "monthly_standard",
- *   amount: 1999, // $19.99 in cents
- *   currency: "usd",
- *   interval: "month",
- *   usage_type: "licensed"
- * };
- * ```
- *
- * @example
- * Tiered usage pricing:
- * ```typescript
- * const tieredPrice: Price = {
- *   id: "api_calls_tiered",
- *   currency: "usd",
- *   usage_type: "metered",
- *   billing_scheme: "tiered",
- *   tiers_mode: "graduated",
- *   tiers: [
- *     { up_to: 1000, unit_amount: 10 }, // First 1000 calls at $0.10 each
- *     { up_to: "inf", unit_amount: 5 }  // Additional calls at $0.05 each
- *   ]
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Configuration
- */
-interface Price {
-    /** Unique identifier for this price */
-    id: string;
-    /**
-     * Price amount in smallest currency unit (e.g., cents for USD)
-     * Omitted for usage-based pricing with tiers
-     */
-    amount?: number;
-    /** Currency code (ISO 4217) */
-    currency: string;
-    /**
-     * Billing interval for recurring prices
-     * - 'month': Monthly billing
-     * - 'year': Annual billing
-     * - 'week': Weekly billing
-     * - 'day': Daily billing
-     */
-    interval?: "month" | "year" | "week" | "day";
-    /**
-     * Number of intervals between billings
-     * @defaultValue 1
-     */
-    interval_count?: number;
-    /**
-     * Usage type determining billing model
-     * - 'licensed': Fixed recurring pricing
-     * - 'metered': Usage-based pricing
-     */
-    usage_type?: "licensed" | "metered";
-    /**
-     * Billing scheme for complex pricing
-     * - 'per_unit': Simple per-unit pricing
-     * - 'tiered': Graduated or volume-based tiers
-     */
-    billing_scheme?: "per_unit" | "tiered";
-    /**
-     * Tier calculation mode (when billing_scheme is 'tiered')
-     * - 'graduated': Each tier applies to usage within that tier
-     * - 'volume': Entire usage charged at the tier rate
-     */
-    tiers_mode?: "graduated" | "volume";
-    /** Pricing tiers for tiered billing */
-    tiers?: Tier[];
-    /** Optional UI customization settings */
-    ui?: PriceUI;
-}
-/**
- * Pricing tier definition for tiered billing
- *
- * Defines a usage range and associated pricing for tiered billing models.
- * Enables graduated pricing where different usage levels have different rates.
- *
- * @example
- * ```typescript
- * const tiers: Tier[] = [
- *   { up_to: 100, flat_amount: 0, unit_amount: 10 },    // First 100 free, then $0.10 each
- *   { up_to: 1000, unit_amount: 5 },                    // Next 900 at $0.05 each
- *   { up_to: "inf", unit_amount: 2 }                    // Beyond 1000 at $0.02 each
- * ];
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Configuration
- */
-interface Tier {
-    /**
-     * Upper bound for this tier
-     * Use "inf" for the highest tier with no upper limit
-     */
-    up_to: number | "inf";
-    /**
-     * Fixed amount charged for this tier (in cents)
-     * Used for flat fees at tier boundaries
-     */
-    flat_amount?: number;
-    /**
-     * Per-unit amount for usage within this tier (in cents)
-     * Applied to each unit of usage in this tier range
-     */
-    unit_amount?: number;
-}
-/**
- * UI customization settings for products
- *
- * Controls how products are displayed in pricing tables and marketing pages.
- * Provides extensive customization options for branding and presentation.
- *
- * @example
- * ```typescript
- * const productUI: ProductUI = {
- *   display_name: "Enterprise",
- *   tagline: "For large organizations",
- *   features: ["SSO integration", "Advanced analytics", "Priority support"],
- *   badge: "Most Popular",
- *   cta_text: "Contact Sales",
- *   highlighted: true,
- *   sort_order: 3
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group UI Configuration
- */
-interface ProductUI {
-    /** Custom display name (overrides product.name) */
-    display_name?: string;
-    /** Marketing tagline or subtitle */
-    tagline?: string;
-    /** List of key features to highlight */
-    features?: string[];
-    /** Optional badge text (e.g., "Popular", "Best Value") */
-    badge?: string;
-    /** Custom call-to-action button text */
-    cta_text?: string;
-    /** Whether to visually highlight this product */
-    highlighted?: boolean;
-    /** Sort order for display (lower numbers first) */
-    sort_order?: number;
-}
-/**
- * UI customization settings for prices
- *
- * Controls how individual price options are displayed within products.
- * Enables custom formatting, feature lists, and usage limits display.
- *
- * @example
- * ```typescript
- * const priceUI: PriceUI = {
- *   display_name: "Annual Billing",
- *   price_display: {
- *     custom_text: "$99/year",
- *     suffix: "billed annually"
- *   },
- *   billing_period: "per year",
- *   features: ["2 months free", "Priority support"],
- *   limits: [
- *     { text: "Up to 10 users", value: 10, unit: "users" },
- *     { text: "100GB storage", value: 100, unit: "GB" }
- *   ]
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group UI Configuration
- */
-interface PriceUI {
-    /** Custom display name for this price option */
-    display_name?: string;
-    /** Custom price display formatting */
-    price_display?: PriceDisplay;
-    /** Custom billing period description */
-    billing_period?: string;
-    /** Price-specific features to highlight */
-    features?: string[];
-    /** Usage limits and quotas for this price */
-    limits?: PriceLimit[];
-}
-/**
- * Custom price display formatting options
- *
- * Provides fine-grained control over how prices are formatted and displayed,
- * including custom text, currency symbols, and suffixes.
- *
- * @example
- * ```typescript
- * const priceDisplay: PriceDisplay = {
- *   custom_text: "Contact us for pricing",
- *   show_currency: false,
- *   suffix: "per month"
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group UI Configuration
- */
-interface PriceDisplay {
-    /**
-     * Custom text to display instead of calculated price
-     * Useful for "Contact us" or "Free" pricing
-     */
-    custom_text?: string;
-    /**
-     * Whether to show currency symbol
-     * @defaultValue true
-     */
-    show_currency?: boolean;
-    /** Additional text to append after the price */
-    suffix?: string;
-}
-/**
- * Usage limit or quota definition
- *
- * Represents a specific limit or quota associated with a price tier,
- * such as user limits, storage quotas, or API call allowances.
- *
- * @example
- * ```typescript
- * const limits: PriceLimit[] = [
- *   { text: "Up to 5 team members", value: 5, unit: "users" },
- *   { text: "50GB storage included", value: 50, unit: "GB" },
- *   { text: "Unlimited API calls" } // No value/unit for unlimited
- * ];
- * ```
- *
- * @since 0.6.0
- * @public
- * @group UI Configuration
- */
-interface PriceLimit {
-    /** Human-readable description of the limit */
-    text: string;
-    /** Numeric value of the limit (omit for unlimited) */
-    value?: number;
-    /** Unit of measurement for the limit */
-    unit?: string;
-}
-/**
- * UI-ready product data structure for pricing tables
- *
- * Extended product interface that includes pre-processed display data
- * optimized for rendering pricing tables and marketing pages. Contains
- * formatted prices, organized features, and display-ready content.
- *
- * This interface is returned by [`getAvailableProducts()`](config.ts) and provides
- * everything needed to render a complete pricing table without additional
- * data processing.
- *
- * @example
- * ```typescript
- * const products: ProductWithPricingUI[] = await configManager.getAvailableProducts();
- *
- * products.forEach(product => {
- *   const display = product.pricing_display;
- *   console.log(`${display.name}: ${display.tagline}`);
- *
- *   display.prices.forEach(price => {
- *     console.log(`  ${price.display_name}: ${price.formatted_price}`);
- *   });
- * });
- * ```
- *
- * @since 0.6.0
- * @public
- * @group UI Configuration
- */
-interface ProductWithPricingUI extends Product {
-    /** Pre-processed display data for UI rendering */
-    pricing_display: {
-        /** Display name for the product */
-        name: string;
-        /** Marketing tagline or subtitle */
-        tagline?: string;
-        /** Key features to highlight */
-        features: string[];
-        /** Optional badge text */
-        badge?: string;
-        /** Call-to-action button text */
-        cta_text: string;
-        /** Whether this product should be visually highlighted */
-        highlighted: boolean;
-        /** Sort order for display */
-        sort_order: number;
-        /** UI-ready price information */
-        prices: Array<{
-            /** Price identifier */
-            id: string;
-            /** Display name for this price option */
-            display_name: string;
-            /** Formatted price string ready for display */
-            formatted_price: string;
-            /** Billing period description */
-            billing_period: string;
-            /** Price-specific features */
-            features: string[];
-            /** Usage limits and quotas */
-            limits: Array<{
-                /** Limit description */
-                text: string;
-                /** Numeric value (if applicable) */
-                value?: number;
-                /** Unit of measurement */
-                unit?: string;
-            }>;
-        }>;
-    };
-}
-
-declare class ConfigManager {
-    private omnibaseClient;
-    constructor(omnibaseClient: OmnibaseClient);
-    /**
-     * Get the current Stripe configuration from the database
-     *
-     * Retrieves the latest Stripe configuration including products, prices,
-     * and UI customization data. This configuration represents the current
-     * active pricing structure with all UI elements for pricing table rendering.
-     *
-     * @returns Promise resolving to the current Stripe configuration
-     *
-     * @throws {Error} When the API request fails due to network issues
-     * @throws {Error} When the server returns an error response (4xx, 5xx status codes)
-     *
-     * @example
-     * Basic usage:
-     * ```typescript
-     * const config = await getStripeConfig();
-     * console.log(`Found ${config.data.config.products.length} products`);
-     *
-     * // Access product UI configuration
-     * config.data.config.products.forEach(product => {
-     *   console.log(`${product.name}: ${product.ui?.tagline || 'No tagline'}`);
-     * });
-     * ```
-     */
-    getStripeConfig(): Promise<StripeConfigResponse>;
-    /**
-     * Get available products with UI-ready pricing data
-     *
-     * Transforms the raw Stripe configuration into UI-ready format for pricing
-     * table rendering. Includes formatted pricing, features, limits, and all
-     * display customizations needed for marketing pages.
-     *
-     * @returns Promise resolving to products ready for UI consumption
-     *
-     * @throws {Error} When the API request fails or configuration is invalid
-     *
-     * @example
-     * Pricing table rendering:
-     * ```typescript
-     * const products = await getAvailableProducts();
-     *
-     * products.forEach(product => {
-     *   const display = product.pricing_display;
-     *   console.log(`${display.name} - ${display.tagline}`);
-     *
-     *   display.prices.forEach(price => {
-     *     console.log(`  ${price.display_name}: ${price.formatted_price}`);
-     *   });
-     * });
-     * ```
-     */
-    getAvailableProducts(): Promise<ProductWithPricingUI[]>;
-    /**
-     * Get a specific product by ID
-     *
-     * Retrieves a single product configuration by its ID from the current
-     * Stripe configuration. Useful for product-specific operations.
-     *
-     * @param productId - The configuration product ID to retrieve
-     * @returns Promise resolving to the product or null if not found
-     *
-     * @example
-     * ```typescript
-     * const product = await getProduct('starter_plan');
-     * if (product) {
-     *   console.log(`Found product: ${product.name}`);
-     * }
-     * ```
-     */
-    getProduct(productId: string): Promise<Product | null>;
-}
-
-/**
- * Configuration options for creating a Stripe customer portal session
- *
- * Defines the parameters needed to create a customer portal session
- * that allows customers to manage their subscription, payment methods,
- * billing history, and other account settings.
- *
- * @example
- * ```typescript
- * const options: PortalOptions = {
- *   return_url: 'https://app.com/billing'
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Portal
- */
-type PortalOptions = {
-    /** URL to redirect the customer to when they exit the portal */
-    return_url: string;
-};
-/**
- * Response from creating a customer portal session
- *
- * Contains the portal session URL for redirecting customers to
- * Stripe's hosted customer portal where they can manage their
- * billing and subscription settings.
- *
- * @since 0.6.0
- * @public
- * @group Portal
- */
-type CreateCustomerPortalResponse = ApiResponse<{
-    /** URL to redirect the customer to for accessing their portal */
-    url: string;
-}>;
-/**
- * Manager for Stripe customer portal operations
- *
- * Handles creation of customer portal sessions that allow customers
- * to manage their own billing information, subscriptions, payment methods,
- * and download invoices through Stripe's hosted portal interface.
- *
- * The customer portal provides a secure, self-service interface that
- * reduces support burden by allowing customers to handle common
- * billing tasks independently.
- *
- * @example
- * ```typescript
- * const portalManager = new PortalManager(omnibaseClient);
- *
- * const portal = await portalManager.create({
- *   return_url: 'https://app.com/billing'
- * });
- *
- * // Redirect customer to portal
- * window.location.href = portal.data.url;
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Portal
- */
-declare class PortalManager {
-    private omnibaseClient;
-    /**
-     * Initialize the portal manager
-     *
-     * @param omnibaseClient - OmnibaseClient instance for API communication
-     *
-     * @group Portal
-     */
-    constructor(omnibaseClient: OmnibaseClient);
-    /**
-     * Create a new customer portal session
-     *
-     * Creates a portal session that allows the specified customer to
-     * manage their billing information, subscriptions, and payment methods.
-     * Returns a URL that the customer should be redirected to.
-     *
-     * The portal session is temporary and expires after a short period
-     * for security. Each access requires creating a new session.
-     *
-     * @param options - Configuration options for the portal session
-     * @param options.return_url - URL to redirect to when exiting the portal
-     *
-     * @returns Promise resolving to portal session response with access URL
-     *
-     * @throws {Error} When the API request fails due to network issues
-     * @throws {Error} When the server returns an error response
-     * @throws {ValidationError} When required parameters are missing or invalid
-     *
-     * @example
-     * ```typescript
-     * const portal = await portalManager.create({
-     *   return_url: 'https://myapp.com/account/billing'
-     * });
-     *
-     * // Redirect user to portal
-     * if (portal.data?.url) {
-     *   window.location.href = portal.data.url;
-     * }
-     * ```
-     *
-     * @since 0.6.0
-     * @group Portal
-     */
-    create(options: PortalOptions): Promise<CreateCustomerPortalResponse>;
-}
-
-/**
- * Configuration options for recording usage events
- *
- * Defines the parameters needed to record a usage event for metered billing.
- * Usage events are used to track consumption of metered products and calculate
- * charges based on actual usage rather than fixed pricing.
- *
- * @example
- * ```typescript
- * const options: UsageOptions = {
- *   meter_event_name: 'api_calls',
- *   value: '1'
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Usage
- */
-type UsageOptions = {
-    /**
-     * Name of the meter event to record usage for
-     * Must match a meter configured in your Stripe billing configuration
-     */
-    meter_event_name: string;
-    /**
-     * Usage value to record as a string
-     * Typically represents quantity consumed (e.g., "1" for single API call, "250" for MB of storage)
-     */
-    value: string;
-};
-/**
- * Manager for usage tracking and metered billing operations
- *
- * Handles recording of usage events for metered billing products. Usage events
- * are used by Stripe to calculate charges for products with usage-based pricing,
- * such as API calls, data transfer, or storage consumption.
- *
- * Usage tracking is essential for accurate metered billing and provides
- * transparency to customers about their consumption patterns.
- *
- * @example
- * ```typescript
- * const usageManager = new UsageManager(omnibaseClient);
- *
- * // Record a single API call
- * await usageManager.recordUsage({
- *   meter_event_name: 'api_calls',
- *   value: '1'
- * });
- *
- * // Record bulk data transfer
- * await usageManager.recordUsage({
- *   meter_event_name: 'data_transfer_gb',
- *   value: '2.5'
- * });
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Usage
- */
-declare class UsageManager {
-    private omnibaseClient;
-    /**
-     * Initialize the usage manager
-     *
-     * @param omnibaseClient - OmnibaseClient instance for API communication
-     *
-     * @group Usage
-     */
-    constructor(omnibaseClient: OmnibaseClient);
-    /**
-     * Record a usage event for metered billing
-     *
-     * Records a usage event against a specific meter for billing calculation.
-     * The event will be aggregated with other usage events for the billing period
-     * to determine the customer's charges for metered products.
-     *
-     * Usage events should be recorded in real-time or as close to real-time as
-     * possible to ensure accurate billing and provide up-to-date usage visibility
-     * to customers.
-     *
-     * @param options - Usage recording options
-     * @param options.meter_event_name - Name of the meter to record against
-     * @param options.value - Usage quantity as string
-     *
-     * @returns Promise resolving to API response confirmation
-     *
-     * @throws {Error} When the API request fails due to network issues
-     * @throws {Error} When the server returns an error response (invalid meter name, customer, etc.)
-     * @throws {ValidationError} When required parameters are missing or invalid
-     *
-     * @example
-     * ```typescript
-     * // Record each API call
-     * await usageManager.recordUsage({
-     *   meter_event_name: 'api_requests',
-     *   value: '1'
-     * });
-     * ```
-     *
-     * @since 0.6.0
-     * @group Usage
-     */
-    recordUsage(options: UsageOptions): Promise<ApiResponse<"">>;
-}
-
-/**
- * Main payment handler for all payment-related operations
- *
- * This class serves as the central coordinator for all payment functionality,
- * providing access to checkout sessions, billing configuration, customer portals,
- * and usage tracking. It delegates specific operations to specialized managers
- * that handle checkout, configuration, portal, and usage operations.
- *
- * The handler provides a consistent interface across all payment operations,
- * with automatic checkout mode detection (subscription vs one-time payment)
- * based on the price configuration retrieved from Stripe.
- *
- * @example
- * ```typescript
- * const paymentHandler = new PaymentHandler(omnibaseClient);
- *
- * // Create a checkout session (mode auto-detected from price)
- * const checkout = await paymentHandler.checkout.createSession({
- *   price_id: 'price_monthly_pro',
- *   success_url: 'https://app.com/success',
- *   cancel_url: 'https://app.com/cancel'
- * });
- *
- * // Get available products
- * const products = await paymentHandler.config.getAvailableProducts();
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Client
- */
-declare class PaymentHandler {
-    private omnibaseClient;
-    /**
-     * Initialize the payment handler with OmnibaseClient
-     *
-     * Creates a new payment handler instance with access to all payment
-     * operations including checkout, configuration, portal, and usage tracking.
-     * The handler uses the provided OmnibaseClient for API communication.
-     *
-     * @param omnibaseClient - OmnibaseClient instance for API communication
-     *
-     * @example
-     * ```typescript
-     * const paymentHandler = new PaymentHandler(omnibaseClient);
-     * ```
-     *
-     * @since 0.6.0
-     * @group Client
-     */
-    constructor(omnibaseClient: OmnibaseClient);
-    /**
-     * Checkout session management
-     *
-     * Provides functionality for creating and managing Stripe checkout sessions
-     * for both one-time payments and subscription billing.
-     *
-     * @example
-     * ```typescript
-     * const session = await paymentHandler.checkout.createSession({
-     *   price_id: 'price_monthly_pro',
-     *   success_url: window.location.origin + '/success',
-     *   cancel_url: window.location.origin + '/pricing'
-     * });
-     *
-     * if (session.data?.url) {
-     *   window.location.href = session.data.url;
-     * }
-     * ```
-     */
-    readonly checkout: CheckoutManager;
-    /**
-     * Stripe configuration management
-     *
-     * Handles retrieval and processing of database-backed Stripe configurations,
-     * providing UI-ready product and pricing data for rendering pricing tables.
-     *
-     * @example
-     * ```typescript
-     * const products = await paymentHandler.config.getAvailableProducts();
-     * const config = await paymentHandler.config.getStripeConfig();
-     * ```
-     */
-    readonly config: ConfigManager;
-    /**
-     * Customer portal management
-     *
-     * Creates customer portal sessions for subscription management,
-     * billing history, and payment method updates.
-     *
-     * @example
-     * ```typescript
-     * const portal = await paymentHandler.portal.create({
-     *   return_url: 'https://app.com/billing'
-     * });
-     * ```
-     */
-    readonly portal: PortalManager;
-    /**
-     * Usage tracking and metered billing
-     *
-     * Records usage events for metered billing products and manages
-     * usage-based pricing calculations.
-     *
-     * @example
-     * ```typescript
-     * await paymentHandler.usage.recordUsage({
-     *   meter_event_name: 'api_calls',
-     *   value: '1'
-     * });
-     * ```
-     */
-    readonly usage: UsageManager;
-}
-
-/**
- * Types for the Permissions and Roles API
- *
- * This module defines TypeScript types for interacting with the Omnibase
- * permissions system, including both Ory Keto relationships and the
- * role-based access control (RBAC) system.
- *
- * @module Permissions Types
- * @since 0.7.0
- */
-/**
- * Namespace definition from the database
- *
- * Represents a permission namespace (e.g., Tenant, Project) and its
- * available relations/permissions. Used for building role configuration UIs.
- *
- * @example
- * ```typescript
- * {
- *   id: 'uuid-123',
- *   namespace: 'Tenant',
- *   relations: ['invite_user', 'delete_tenant', 'manage_billing'],
- *   created_at: '2024-01-01T00:00:00Z',
- *   updated_at: '2024-01-01T00:00:00Z'
- * }
- * ```
- *
- * @since 0.7.0
- * @public
- */
-interface NamespaceDefinition {
-    /**
-     * Unique identifier for the namespace definition
-     */
-    id: string;
-    /**
-     * Name of the namespace (e.g., 'Tenant', 'Project')
-     */
-    namespace: string;
-    /**
-     * Available relations/permissions for this namespace
-     * @example ['invite_user', 'delete_tenant', 'manage_billing']
-     */
-    relations: string[];
-    /**
-     * Timestamp when the namespace definition was created
-     */
-    created_at: string;
-    /**
-     * Timestamp when the namespace definition was last updated
-     */
-    updated_at: string;
-}
-/**
- * Role model representing a collection of permissions
- *
- * Roles can be system-wide (tenant_id = null) or tenant-specific.
- * System roles are defined in roles.config.json and apply to all tenants.
- * Custom roles are created via the API and are specific to a tenant.
- *
- * @example
- * System role:
- * ```typescript
- * {
- *   id: 'role_123',
- *   tenant_id: null,
- *   role_name: 'admin',
- *   permissions: ['tenant#delete_all_projects', 'tenant#manage_billing'],
- *   user_ids: ['user_456', 'user_789'],
- *   created_at: '2024-01-01T00:00:00Z',
- *   updated_at: '2024-01-01T00:00:00Z'
- * }
- * ```
- *
- * @example
- * Custom tenant role:
- * ```typescript
- * {
- *   id: 'role_456',
- *   tenant_id: 'tenant_123',
- *   role_name: 'billing_manager',
- *   permissions: ['tenant#manage_billing', 'tenant#view_invoices'],
- *   user_ids: ['user_999'],
- *   created_at: '2024-01-01T00:00:00Z',
- *   updated_at: '2024-01-01T00:00:00Z'
- * }
- * ```
- *
- * @since 0.7.0
- * @public
- */
-interface Role {
-    /**
-     * Unique identifier for the role
-     */
-    id: string;
-    /**
-     * Tenant ID this role belongs to, or null for system roles
-     *
-     * - `null`: System role (applies to all tenants)
-     * - `string`: Tenant-specific custom role
-     */
-    tenant_id: string | null;
-    /**
-     * Human-readable name for the role
-     * @example 'admin', 'billing_manager', 'developer'
-     */
-    role_name: string;
-    /**
-     * Array of permission strings in format: namespace#relation or namespace:id#relation
-     *
-     * @example
-     * Tenant-wide permissions:
-     * - 'tenant#invite_user'
-     * - 'tenant#delete_all_projects'
-     *
-     * Resource-specific permissions:
-     * - 'project:proj_abc123#deploy'
-     * - 'project:proj_abc123#view_logs'
-     */
-    permissions: string[];
-    /**
-     * Array of user IDs assigned to this role
-     *
-     * When a user is assigned to a role, their ID is added here and
-     * corresponding Keto relationship tuples are created for each permission.
-     */
-    user_ids: string[];
-    /**
-     * Timestamp when the role was created
-     */
-    created_at: string;
-    /**
-     * Timestamp when the role was last updated
-     */
-    updated_at: string;
-}
-/**
- * Request body for creating a new role
- *
- * @example
- * ```typescript
- * {
- *   role_name: 'billing_manager',
- *   permissions: [
- *     'tenant#manage_billing',
- *     'tenant#view_invoices',
- *     'tenant#update_payment_methods'
- *   ]
- * }
- * ```
- *
- * @since 0.7.0
- * @public
- */
-interface CreateRoleRequest {
-    /**
-     * Name for the new role
-     * @example 'billing_manager', 'support_agent', 'developer'
-     */
-    role_name: string;
-    /**
-     * Array of permission strings to assign to the role
-     * @example ['tenant#manage_billing', 'tenant#view_invoices']
-     */
-    permissions: string[];
-}
-/**
- * Request body for updating an existing role's permissions
- *
- * @example
- * ```typescript
- * {
- *   permissions: [
- *     'tenant#manage_billing',
- *     'tenant#view_invoices',
- *     'tenant#manage_users' // Added new permission
- *   ]
- * }
- * ```
- *
- * @since 0.7.0
- * @public
- */
-interface UpdateRoleRequest {
-    /**
-     * New array of permissions for the role
-     *
-     * This replaces all existing permissions. Old permissions are removed
-     * from Keto and new ones are created for all assigned users.
-     */
-    permissions: string[];
-}
-/**
- * Request body for assigning a role to a user
- *
- * Supports assigning by either role ID or role name for flexibility.
- * When using role_name, the system will find the role by name within
- * the current tenant's scope (including system roles).
- *
- * @example
- * By role ID:
- * ```typescript
- * {
- *   role_id: 'role_456'
- * }
- * ```
- *
- * @example
- * By role name:
- * ```typescript
- * {
- *   role_name: 'owner'
- * }
- * ```
- *
- * @since 0.7.0
- * @public
- */
-interface AssignRoleRequest {
-    /**
-     * ID of the role to assign to the user
-     * Use either role_id or role_name, not both
-     */
-    role_id?: string;
-    /**
-     * Name of the role to assign to the user
-     * Use either role_id or role_name, not both
-     * @example 'owner', 'admin', 'billing_manager'
-     */
-    role_name?: string;
-}
-
-/**
- * Handler for managing roles and role-based permissions
- *
- * Provides methods for creating custom roles, assigning permissions,
- * and managing role assignments. Works alongside the Keto-based
- * permissions system to provide dynamic RBAC capabilities.
- *
- * @example
- * ```typescript
- * // Create a custom role
- * const role = await omnibase.permissions.roles.create({
- *   role_name: 'billing_manager',
- *   permissions: ['tenant#manage_billing', 'tenant#view_invoices']
- * });
- *
- * // Assign role to user
- * await omnibase.permissions.roles.assign('user_123', {
- *   role_id: role.id
- * });
- * ```
- *
- * @since 0.7.0
- * @public
- */
-declare class RolesHandler {
-    private client;
-    constructor(client: OmnibaseClient);
-    /**
-     * Get available namespace definitions for UI
-     *
-     * Returns all namespaces and their available relations/permissions.
-     * Useful for building role configuration UIs.
-     *
-     * @returns List of namespace definitions
-     *
-     * @example
-     * ```typescript
-     * const definitions = await omnibase.permissions.roles.getDefinitions();
-     *
-     * // Output: [{ namespace: 'Tenant', relations: ['invite_user', 'delete_tenant', ...] }]
-     * definitions.forEach(def => {
-     *   console.log(`${def.namespace} supports: ${def.relations.join(', ')}`);
-     * });
-     * ```
-     */
-    getDefinitions(): Promise<NamespaceDefinition[]>;
-    /**
-     * List all roles for the current tenant
-     *
-     * Returns both system roles (defined in roles.config.json) and
-     * custom roles created via the API. System roles have `tenant_id = null`.
-     *
-     * @returns List of roles
-     *
-     * @example
-     * ```typescript
-     * const roles = await omnibase.permissions.roles.list();
-     *
-     * const systemRoles = roles.filter(r => r.tenant_id === null);
-     * const customRoles = roles.filter(r => r.tenant_id !== null);
-     *
-     * console.log(`System roles: ${systemRoles.map(r => r.role_name).join(', ')}`);
-     * console.log(`Custom roles: ${customRoles.map(r => r.role_name).join(', ')}`);
-     * ```
-     */
-    list(): Promise<Role[]>;
-    /**
-     * Create a new custom role
-     *
-     * Creates a tenant-specific role with the specified permissions.
-     * Permissions use the format `namespace#relation` or `namespace:id#relation`.
-     *
-     * @param request - Role creation request
-     * @returns Created role
-     *
-     * @example
-     * ```typescript
-     * const role = await omnibase.permissions.roles.create({
-     *   role_name: 'billing_manager',
-     *   permissions: [
-     *     'tenant#manage_billing',
-     *     'tenant#view_invoices',
-     *     'tenant#update_payment_methods'
-     *   ]
-     * });
-     *
-     * console.log(`Created role: ${role.id}`);
-     * ```
-     *
-     * @example
-     * Resource-specific permissions:
-     * ```typescript
-     * const devRole = await omnibase.permissions.roles.create({
-     *   role_name: 'project_developer',
-     *   permissions: [
-     *     'project:proj_abc123#deploy',
-     *     'project:proj_abc123#view_logs',
-     *     'tenant#invite_user'
-     *   ]
-     * });
-     * ```
-     */
-    create(request: CreateRoleRequest): Promise<Role>;
-    /**
-     * Update an existing role's permissions
-     *
-     * Updates the permissions for a role and automatically updates all
-     * Keto relationships for users assigned to this role. Old permissions
-     * are removed and new ones are created.
-     *
-     * @param roleId - ID of role to update
-     * @param request - Update request with new permissions
-     * @returns Updated role
-     *
-     * @example
-     * ```typescript
-     * const updatedRole = await omnibase.permissions.roles.update('role_123', {
-     *   permissions: [
-     *     'tenant#manage_billing',
-     *     'tenant#view_invoices',
-     *     'tenant#manage_users' // Added new permission
-     *   ]
-     * });
-     *
-     * console.log(`Updated role with ${updatedRole.permissions.length} permissions`);
-     * ```
-     */
-    update(roleId: string, request: UpdateRoleRequest): Promise<Role>;
-    /**
-     * Delete a role
-     *
-     * Deletes the role and automatically removes all Keto relationships
-     * for users assigned to this role. Cannot delete system roles.
-     *
-     * @param roleId - ID of role to delete
-     *
-     * @example
-     * ```typescript
-     * await omnibase.permissions.roles.delete('role_123');
-     * console.log('Role deleted successfully');
-     * ```
-     */
-    delete(roleId: string): Promise<void>;
-    /**
-     * Assign a role to a user
-     *
-     * Assigns a role to a user and automatically creates all necessary
-     * Keto relationship tuples based on the role's permissions. The user
-     * immediately gains all permissions defined in the role.
-     *
-     * Supports assignment by either role ID or role name for flexibility.
-     *
-     * @param userId - ID of user to assign role to
-     * @param request - Assignment request with either role_id or role_name
-     *
-     * @example
-     * Assign by role ID:
-     * ```typescript
-     * await omnibase.permissions.roles.assign('user_123', {
-     *   role_id: 'role_456'
-     * });
-     * ```
-     *
-     * @example
-     * Assign by role name (system or custom role):
-     * ```typescript
-     * // Assign system role
-     * await omnibase.permissions.roles.assign('user_123', {
-     *   role_name: 'owner'
-     * });
-     *
-     * // Assign custom role
-     * await omnibase.permissions.roles.assign('user_456', {
-     *   role_name: 'billing_manager'
-     * });
-     * ```
-     *
-     * @example
-     * Verify permissions after assignment:
-     * ```typescript
-     * await omnibase.permissions.roles.assign('user_123', {
-     *   role_name: 'admin'
-     * });
-     *
-     * // User now has all permissions from the admin role
-     * const canManage = await omnibase.permissions.permissions.checkPermission(
-     *   undefined,
-     *   {
-     *     namespace: 'Tenant',
-     *     object: 'tenant_789',
-     *     relation: 'manage_billing',
-     *     subjectId: 'user_123'
-     *   }
-     * );
-     * // canManage.data.allowed === true
-     * ```
-     */
-    assign(userId: string, request: AssignRoleRequest): Promise<void>;
-}
-
-/**
- * Client for managing permissions and relationships using Ory Keto
- *
- * This client provides access to Ory Keto's permission system through Omnibase's API,
- * allowing you to create, manage, and check relationships between subjects and objects.
- * It handles both read operations (permission checks) and write operations (relationship management).
- *
- * The client automatically configures separate endpoints for read and write operations:
- * - Read operations (permission checks): `/api/v1/permissions/read`
- * - Write operations (relationship management): `/api/v1/permissions/write`
- *
- * This separation optimizes performance and security by following Ory Keto's recommended architecture.
- *
- * @example
- * Initialize the permissions client:
- * ```typescript
- * import { OmnibaseClient } from '@omnibase/core-js';
- *
- * const omnibase = new OmnibaseClient({
- *   apiUrl: 'https://api.example.com'
- * });
- *
- * // Access permissions client
- * const permissions = omnibase.permissions;
- * ```
- *
- * @example
- * Check if a user has permission:
- * ```typescript
- * // Check if a user can view a tenant
- * const result = await omnibase.permissions.permissions.checkPermission({
- *   namespace: 'Tenant',
- *   object: 'tenant_123',
- *   relation: 'view',
- *   subjectId: 'user_456'
- * });
- *
- * if (result.data.allowed) {
- *   console.log('User can view the tenant');
- * }
- * ```
- *
- * @example
- * Create relationships:
- * ```typescript
- * // Make a user an owner of a tenant
- * await omnibase.permissions.relationships.createRelationship({
- *   namespace: 'Tenant',
- *   object: 'tenant_123',
- *   relation: 'owners',
- *   subjectId: 'user_456'
- * });
- * ```
- *
- * @example
- * Query existing relationships:
- * ```typescript
- * // Get all members of a tenant
- * const relationships = await omnibase.permissions.relationships.getRelationships({
- *   namespace: 'Tenant',
- *   object: 'tenant_123',
- *   relation: 'members'
- * });
- *
- * console.log('Tenant members:', relationships.data.relation_tuples);
- * ```
- *
- * @example
- * Delete relationships:
- * ```typescript
- * // Remove a user from tenant admins
- * await omnibase.permissions.relationships.deleteRelationships({
- *   namespace: 'Tenant',
- *   object: 'tenant_123',
- *   relation: 'admins',
- *   subjectId: 'user_456'
- * });
- * ```
- *
- * @since 1.0.0
- * @public
- * @group Client
- */
-declare class PermissionsClient {
-    /**
-     * Ory Keto RelationshipApi for managing subject-object relationships
-     *
-     * Provides methods for creating, updating, and deleting relationships between
-     * subjects (users, groups) and objects (tenants, resources). This API handles
-     * write operations and is used to establish permission structures.
-     *
-     * Key methods:
-     * - `createRelationship()` - Creates a new relationship tuple
-     * - `deleteRelationships()` - Removes existing relationship tuples
-     * - `getRelationships()` - Queries existing relationships
-     * - `patchRelationships()` - Updates multiple relationships atomically
-     *
-     * @example
-     * ```typescript
-     * // Create a relationship
-     * await client.relationships.createRelationship(
-     *   undefined,
-     *   {
-     *     namespace: 'Tenant',
-     *     object: 'tenant_123',
-     *     relation: 'members',
-     *     subjectId: 'user_456'
-     *   }
-     * );
-     * ```
-     *
-     * @since 1.0.0
-     * @group Relationships
-     */
-    relationships: RelationshipApi;
-    /**
-     * Ory Keto PermissionApi for checking permissions
-     *
-     * Provides methods for querying whether a subject has a specific permission
-     * on an object. This API handles read operations and is optimized for fast
-     * permission checks in your application logic.
-     *
-     * All operations are proxied through Omnibase's API at `/api/v1/permissions/read`.
-     *
-     * Key methods:
-     * - `checkPermission(params)` - Checks if a subject has permission on an object
-     * - `checkPermissionOrError(params)` - Same as above but throws error if denied
-     * - `expandPermissions(namespace, object, relation, maxDepth?)` - Expands relationships to show all granted permissions
-     * - `postCheckPermission(maxDepth?, body)` - POST variant of permission check
-     *
-     * @example
-     * Check a single permission:
-     * ```typescript
-     * const result = await omnibase.permissions.permissions.checkPermission({
-     *   namespace: 'Tenant',
-     *   object: 'tenant_123',
-     *   relation: 'view',
-     *   subjectId: 'user_456'
-     * });
-     *
-     * if (result.data.allowed) {
-     *   console.log('User has permission');
-     * }
-     * ```
-     *
-     * @example
-     * Expand permission tree:
-     * ```typescript
-     * const tree = await omnibase.permissions.permissions.expandPermissions(
-     *   'Tenant',
-     *   'tenant_123',
-     *   'view'
-     * );
-     *
-     * console.log('Permission tree:', tree.data);
-     * ```
-     *
-     * @example
-     * Check permission or throw error:
-     * ```typescript
-     * try {
-     *   await omnibase.permissions.permissions.checkPermissionOrError({
-     *     namespace: 'Tenant',
-     *     object: 'tenant_123',
-     *     relation: 'edit',
-     *     subjectId: 'user_456'
-     *   });
-     *   // Permission granted
-     * } catch (error) {
-     *   // Permission denied
-     *   console.error('Access denied');
-     * }
-     * ```
-     *
-     * @since 1.0.0
-     * @group Permissions
-     */
-    permissions: PermissionApi;
-    /**
-     * Handler for managing roles and role-based permissions
-     *
-     * Provides methods for creating custom roles, assigning permissions,
-     * and managing role assignments. Works alongside the Keto-based
-     * permissions system to provide dynamic RBAC capabilities.
-     *
-     * Roles are stored in the database and automatically synchronized with
-     * Ory Keto relationships, providing a higher-level abstraction over
-     * raw relationship tuples.
-     *
-     * @example
-     * Create a custom role:
-     * ```typescript
-     * const role = await omnibase.permissions.roles.create({
-     *   role_name: 'billing_manager',
-     *   permissions: ['tenant#manage_billing', 'tenant#view_invoices']
-     * });
-     * ```
-     *
-     * @example
-     * Assign role to a user:
-     * ```typescript
-     * await omnibase.permissions.roles.assign('user_123', {
-     *   role_id: role.id
-     * });
-     * ```
-     *
-     * @example
-     * List all roles:
-     * ```typescript
-     * const roles = await omnibase.permissions.roles.list();
-     * console.log('Available roles:', roles);
-     * ```
-     *
-     * @since 0.7.0
-     * @group Roles
-     */
-    roles: RolesHandler;
-    /**
-     * Creates a new PermissionsClient instance
-     *
-     * Initializes the client with separate endpoints for read and write operations.
-     * The client automatically configures the Ory Keto client libraries to use
-     * Omnibase's permission proxy endpoints:
-     * - Write endpoint: `${apiBaseUrl}/api/v1/permissions/write`
-     * - Read endpoint: `${apiBaseUrl}/api/v1/permissions/read`
-     *
-     * This separation follows Ory Keto's recommended architecture for optimal
-     * performance and security.
-     *
-     * @param apiBaseUrl - The base URL for your Omnibase API instance (e.g., 'https://api.example.com')
-     * @param client - The main OmnibaseClient instance (required for roles handler)
-     *
-     * @throws {Error} When the base URL is invalid or cannot be reached
-     *
-     * @example
-     * Direct instantiation (not recommended - use OmnibaseClient instead):
-     * ```typescript
-     * const client = new PermissionsClient('https://api.example.com', omnibaseClient);
-     * ```
-     *
-     * @example
-     * Recommended usage via OmnibaseClient:
-     * ```typescript
-     * import { OmnibaseClient } from '@omnibase/core-js';
-     *
-     * const omnibase = new OmnibaseClient({
-     *   apiUrl: 'https://api.example.com'
-     * });
-     *
-     * // Use the permissions client
-     * await omnibase.permissions.permissions.checkPermission({
-     *   namespace: 'Tenant',
-     *   object: 'tenant_123',
-     *   relation: 'view',
-     *   subjectId: 'user_456'
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     * @group Client
-     */
-    constructor(apiBaseUrl: string, client: OmnibaseClient);
-}
-
-interface UploadOptions {
-    /**
-     * Custom metadata to attach to the file
-     * This will be stored in the JSONB metadata column
-     */
-    metadata?: Record<string, any>;
-}
-interface UploadResult {
-    /**
-     * Pre-signed URL for uploading the file
-     */
-    upload_url: string;
-    /**
-     * Full path where the file is stored
-     */
-    path: string;
-}
-interface DownloadResult {
-    /**
-     * Pre-signed URL for downloading the file
-     */
-    download_url: string;
-}
-/**
- * Storage client for file operations with path-based organization
- *
- * Users control the full file path and define RLS policies based on path patterns.
- * Common patterns:
- * - `public/*` - Public files
- * - `users/{user_id}/*` - User private files
- * - `teams/{team_id}/*` - Team shared files
- *
- * @example
- * ```typescript
- * const storage = omnibase.storage();
- *
- * // Upload to public directory
- * await storage.upload('public/images/avatar.png', file);
- *
- * // Upload to user private directory
- * await storage.upload('users/123/documents/report.pdf', file, {
- *   metadata: {
- *     department: 'engineering',
- *     confidential: true
- *   }
- * });
- *
- * // Download file
- * const { download_url } = await storage.download('public/images/avatar.png');
- *
- * // Delete file
- * await storage.delete('users/123/documents/report.pdf');
- * ```
- */
-declare class StorageClient {
-    private client;
-    constructor(client: OmnibaseClient);
-    /**
-     * Upload a file to storage
-     *
-     * @param path - Full path for the file (e.g., "public/images/avatar.png", "users/123/private/doc.pdf")
-     * @param file - File or Blob to upload
-     * @param options - Upload options including custom metadata
-     *
-     * @example
-     * ```typescript
-     * const result = await storage.upload(
-     *   'public/avatars/user-123.png',
-     *   file,
-     *   {
-     *     metadata: {
-     *       userId: '123',
-     *       uploadedBy: 'john@example.com',
-     *       tags: ['profile', 'avatar']
-     *     }
-     *   }
-     * );
-     *
-     * // File is automatically uploaded to S3 via the presigned URL
-     * console.log('File uploaded to:', result.path);
-     * ```
-     */
-    upload(path: string, file: File | Blob, options?: UploadOptions): Promise<UploadResult>;
-    /**
-     * Download a file from storage
-     *
-     * @param path - Full path to the file
-     *
-     * @example
-     * ```typescript
-     * const { download_url } = await storage.download('public/images/logo.png');
-     *
-     * // Download the file
-     * const response = await fetch(download_url);
-     * const blob = await response.blob();
-     * ```
-     */
-    download(path: string): Promise<DownloadResult>;
-    /**
-     * Delete a file from storage
-     *
-     * @param path - Full path to the file
-     *
-     * @example
-     * ```typescript
-     * await storage.delete('users/123/documents/old-report.pdf');
-     * ```
-     */
-    delete(path: string): Promise<void>;
-}
-
-/**
- * Request data for accepting a tenant invitation
- *
- * Contains the secure token that was provided in the invitation.
- * This token is validated server-side to ensure the invitation
- * is legitimate, not expired, and hasn't been used before.
- *
- * @example
- * ```typescript
- * const acceptData: AcceptTenantInviteRequest = {
- *   token: 'inv_secure_token_abc123xyz'
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Invitations
- */
-type AcceptTenantInviteRequest = {
-    /** Secure invitation token from the email invitation */
-    token: string;
-};
-/**
- * Response structure for accepting a tenant invitation
- *
- * Contains the ID of the tenant that the user has successfully joined
- * along with a confirmation message. After accepting an invitation,
- * the user becomes a member of the tenant with the role specified
- * in the original invitation.
- *
- * @example
- * ```typescript
- * const response: AcceptTenantInviteResponse = {
- *   data: {
- *     tenant_id: 'tenant_abc123',
- *     message: 'Successfully joined tenant'
- *   },
- *   status: 200
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Invitations
- */
-type AcceptTenantInviteResponse = ApiResponse<{
-    /** ID of the tenant the user has joined */
-    tenant_id: string;
-    /** Success message confirming the invitation acceptance */
-    message: string;
-    /** JWT token for postgrest RLS */
-    token: string;
-}>;
-/**
- * Response structure for tenant user invite creation
- *
- * Contains the newly created invite information including the secure token
- * that will be sent to the invitee. The invite has an expiration time and
- * can only be used once to join the specified tenant.
- *
- * @example
- * ```typescript
- * const response: CreateTenantUserInviteResponse = {
- *   data: {
- *     invite: {
- *       id: 'invite_123',
- *       tenant_id: 'tenant_abc',
- *       email: 'colleague@company.com',
- *       role: 'member',
- *       token: 'inv_secure_token_xyz',
- *       expires_at: '2024-02-15T10:30:00Z'
- *     },
- *     message: 'Invite created successfully'
- *   },
- *   status: 201
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Invitations
- */
-type CreateTenantUserInviteResponse = ApiResponse<{
-    /** The newly created tenant invite */
-    invite: TenantInvite;
-    /** Success message confirming invite creation */
-    message: string;
-}>;
-/**
- * Tenant invitation entity structure
- *
- * Represents a pending invitation for a user to join a specific tenant
- * with a defined role. The invite contains a secure token that expires
- * after a certain time period and can only be used once.
- *
- * @example
- * ```typescript
- * const invite: TenantInvite = {
- *   id: 'invite_abc123',
- *   tenant_id: 'tenant_xyz789',
- *   email: 'newuser@company.com',
- *   role: 'member',
- *   token: 'inv_secure_abc123xyz',
- *   inviter_id: 'user_owner123',
- *   expires_at: '2024-02-01T12:00:00Z',
- *   created_at: '2024-01-25T12:00:00Z',
- *   used_at: undefined // null until invite is accepted
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Invitations
- */
-type TenantInvite = {
-    /** Unique identifier for the invitation */
-    id: string;
-    /** ID of the tenant the user is being invited to */
-    tenant_id: string;
-    /** Email address of the invited user */
-    email: string;
-    /** Role the user will have in the tenant (e.g., 'owner', 'admin', 'member') */
-    role: string;
-    /** Secure token used to accept the invitation */
-    token: string;
-    /** ID of the user who created this invitation */
-    inviter_id: string;
-    /** ISO 8601 timestamp when the invitation expires */
-    expires_at: string;
-    /** ISO 8601 timestamp when the invitation was created */
-    created_at: string;
-    /** ISO 8601 timestamp when the invitation was accepted (null if unused) */
-    used_at?: string;
-};
-/**
- * Required data for creating a tenant user invitation
- *
- * Specifies the email address of the user to invite, their intended
- * role within the tenant, and the invitation URL that will be sent in the email.
- * The role determines what permissions the user will have once they accept the invitation.
- * The invite_url will be automatically appended with ?token=XYZ when sent to the user.
- *
- * @example
- * ```typescript
- * const inviteData: CreateTenantUserInviteRequest = {
- *   email: 'developer@company.com',
- *   role: 'admin',
- *   invite_url: 'https://yourapp.com/accept-invite'
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Invitations
- */
-type CreateTenantUserInviteRequest = {
-    /** Email address of the user to invite */
-    email: string;
-    /** Role the invited user will have in the tenant */
-    role: string;
-    /** Invite URL - the link that will be sent to the user's email, automatically suffixed with ?token=XYZ */
-    invite_url: string;
-};
-/**
- * Tenant invitation management handler
- *
- * This class handles all tenant invitation operations including creating
- * invitations for new users and processing invitation acceptances. It provides
- * a secure, email-based invitation workflow with role-based access control
- * and token-based security.
- *
- * The manager handles:
- * - Creating secure invitations with time-limited tokens
- * - Processing invitation acceptances with validation
- * - Email workflow integration (server-side)
- * - Role assignment and permission setup
- * - Security validation and anti-abuse measures
- *
- * All invitation operations respect tenant permissions and ensure that only
- * authorized users can invite others to their tenants.
- *
- * @example
- * ```typescript
- * const inviteManager = new TenantInviteManager(omnibaseClient);
- *
- * // Create an invitation
- * const invite = await inviteManager.create({
- *   email: 'colleague@company.com',
- *   role: 'member',
- *   invite_url: 'https://yourapp.com/accept-invite'
- * });
- *
- * // Accept an invitation (from the invited user's session)
- * const result = await inviteManager.accept('invite_token_xyz');
- * console.log(`Joined tenant: ${result.data.tenant_id}`);
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Invitations
- */
-declare class TenantInviteManager {
-    private omnibaseClient;
-    /**
-     * Creates a new TenantInviteManager instance
-     *
-     * Initializes the manager with the provided Omnibase client for making
-     * authenticated API requests to tenant invitation endpoints.
-     *
-     * @param omnibaseClient - Configured Omnibase client instance
-     *
-     * @group Tenant Invitations
-     */
-    constructor(omnibaseClient: OmnibaseClient);
-    /**
-     * Accepts a tenant invitation using a secure token
-     *
-     * Processes a tenant invitation by validating the provided token and
-     * adding the authenticated user to the specified tenant. The invitation
-     * token is consumed during this process and cannot be used again.
-     *
-     * The function performs several validations:
-     * - Verifies the token exists and is valid
-     * - Checks that the invitation hasn't expired
-     * - Ensures the invitation hasn't already been used
-     * - Confirms the user is authenticated via session cookies
-     *
-     * Upon successful acceptance, the user is granted access to the tenant
-     * with the role specified in the original invitation. The invitation
-     * record is marked as used and cannot be accepted again.
-     *
-     * @param token - The secure invitation token from the email invitation
-     *
-     * @returns Promise resolving to the tenant ID and success confirmation
-     *
-     * @throws {Error} When the token parameter is missing or empty
-     * @throws {Error} When the invitation token is invalid or expired
-     * @throws {Error} When the invitation has already been accepted
-     * @throws {Error} When the user is not authenticated
-     * @throws {Error} When the API request fails due to network issues
-     * @throws {Error} When the server returns an error response (4xx, 5xx status codes)
-     *
-     * @example
-     * ```typescript
-     * // Typically called from an invitation link like:
-     * // https://app.com/accept-invite?token=inv_secure_token_abc123
-     *
-     * const urlParams = new URLSearchParams(window.location.search);
-     * const inviteToken = urlParams.get('token');
-     *
-     * if (inviteToken) {
-     *   try {
-     *     const result = await inviteManager.accept(inviteToken);
-     *
-     *     // Success - redirect to tenant dashboard
-     *     console.log(`Successfully joined tenant: ${result.data.tenant_id}`);
-     *     window.location.href = `/dashboard?tenant=${result.data.tenant_id}`;
-     *   } catch (error) {
-     *     console.error('Failed to accept invitation:', error.message);
-     *   }
-     * }
-     * ```
-     *
-     * @since 0.6.0
-     * @public
-     * @group Tenant Invitations
-     */
-    accept(token: string): Promise<AcceptTenantInviteResponse>;
-    /**
-     * Creates a new user invitation for the active tenant
-     *
-     * Generates a secure invitation that allows a user to join the currently active
-     * tenant with the defined role. The invitation is sent to the provided email address
-     * and includes a time-limited token for security. The invite URL will be automatically
-     * appended with ?token=XYZ when sent to the user.
-     *
-     * The function creates the invitation record in the database and triggers an email
-     * notification to the invited user. The invitation expires after 7 days and can only
-     * be used once.
-     *
-     * Only existing tenant members with appropriate permissions (invite_user permission)
-     * can create invitations. The inviter's authentication and tenant context are validated
-     * via HTTP-only cookies sent with the request.
-     *
-     * @param inviteData - Configuration object for the invitation
-     * @param inviteData.email - Email address of the user to invite
-     * @param inviteData.role - Role the user will have after joining (e.g., 'member', 'admin')
-     * @param inviteData.invite_url - Base URL for the invitation link (will be appended with ?token=XYZ)
-     *
-     * @returns Promise resolving to the created invitation with secure token
-     *
-     * @throws {Error} When required fields (email, role, invite_url) are missing or empty
-     * @throws {Error} When the user doesn't have permission to invite users to the tenant
-     * @throws {Error} When the API request fails due to network issues
-     * @throws {Error} When the server returns an error response (4xx, 5xx status codes)
-     *
-     * @example
-     * ```typescript
-     * const invite = await inviteManager.create({
-     *   email: 'colleague@company.com',
-     *   role: 'member',
-     *   invite_url: 'https://yourapp.com/accept-invite'
-     * });
-     *
-     * console.log(`Invite sent to: ${invite.data.invite.email}`);
-     * console.log(`Invite token: ${invite.data.invite.token}`);
-     * ```
-     *
-     * @since 0.6.0
-     * @public
-     * @group Tenant Invitations
-     */
-    create(inviteData: CreateTenantUserInviteRequest): Promise<CreateTenantUserInviteResponse>;
-}
-
-/**
- * Response structure for switching the active tenant
- *
- * Contains a new JWT token that includes the updated tenant context
- * and a confirmation message. The new token should replace the previous
- * token for all subsequent API calls to ensure requests are made within
- * the context of the newly active tenant.
- *
- * The token includes updated tenant-specific claims and permissions,
- * ensuring that row-level security policies are enforced correctly
- * for the new active tenant context.
- *
- * @example
- * ```typescript
- * const response: SwitchActiveTenantResponse = {
- *   data: {
- *     token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
- *     message: 'Active tenant switched successfully'
- *   },
- *   status: 200
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Management
- */
-type SwitchActiveTenantResponse = ApiResponse<{
-    /** New JWT token with updated tenant context */
-    token: string;
-    /** Success message confirming the tenant switch */
-    message: string;
-}>;
-/**
- * Response structure for deleting a tenant
- *
- * Contains a confirmation message indicating successful tenant deletion.
- * This response is only returned after the tenant and all associated data
- * have been permanently removed from the system.
- *
- * @example
- * ```typescript
- * const response: DeleteTenantResponse = {
- *   data: {
- *     message: 'Tenant deleted successfully'
- *   },
- *   status: 200
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Management
- */
-type DeleteTenantResponse = ApiResponse<{
-    /** Confirmation message indicating successful deletion */
-    message: string;
-}>;
-/**
- * Response structure for tenant creation operations
- *
- * Contains the newly created tenant information along with an authentication
- * token that provides Row-Level Security (RLS) access to the tenant's data.
- * The token should be stored securely and used for subsequent API calls
- * that require tenant-specific access.
- *
- * @example
- * ```typescript
- * const response: CreateTenantResponse = {
- *   data: {
- *     tenant: {
- *       id: 'tenant_123',
- *       name: 'My Company',
- *       stripe_customer_id: 'cus_abc123'
- *     },
- *     message: 'Tenant created successfully',
- *     token: 'eyJhbGciOiJIUzI1NiIs...'
- *   },
- *   status: 201
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Management
- */
-type CreateTenantResponse = ApiResponse<{
-    /** The newly created tenant object */
-    tenant: Tenant;
-    /** Success message confirming tenant creation */
-    message: string;
-    /** JWT token for RLS policies specific to the active tenant */
-    token: string;
-}>;
-/**
- * Tenant entity structure that maps to the database schema
- *
- * Represents a tenant in the multi-tenant system with billing integration
- * via Stripe. Each tenant can have multiple users with different roles
- * and maintains its own isolated data through RLS policies.
- *
- * @example
- * ```typescript
- * const tenant: Tenant = {
- *   id: 'tenant_abc123',
- *   name: 'Acme Corporation',
- *   stripe_customer_id: 'cus_stripe123',
- *   type: 'business',
- *   created_at: '2024-01-15T10:30:00Z',
- *   updated_at: '2024-01-15T10:30:00Z'
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Management
- */
-type Tenant = {
-    /** Unique identifier for the tenant */
-    id: string;
-    /** Display name of the tenant organization */
-    name: string;
-    /** Associated Stripe customer ID for billing */
-    stripe_customer_id: string;
-    /** Type of tenant (e.g., 'individual', 'organization') */
-    type: string;
-    /** ISO 8601 timestamp when the tenant was created */
-    created_at: string;
-    /** ISO 8601 timestamp when the tenant was last updated */
-    updated_at: string;
-};
-/**
- * Required data for creating a new tenant
- *
- * Contains the essential information needed to establish a new tenant
- * in the system, including billing setup and initial user assignment.
- *
- * @example
- * ```typescript
- * const tenantData: CreateTenantRequest = {
- *   name: 'My New Company',
- *   billing_email: 'billing@mynewcompany.com',
- *   user_id: 'user_abc123'
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Management
- */
-type CreateTenantRequest = {
-    /** Name of the tenant organization */
-    name: string;
-    /** Email address for billing notifications */
-    billing_email: string;
-    /** ID of the user who will own the tenant */
-    user_id: string;
-};
-/**
- * Tenant management operations handler
- *
- * This class provides core tenant lifecycle management operations including
- * creation, deletion, and active tenant switching. It handles all the fundamental
- * operations needed to manage tenants in a multi-tenant application with
- * integrated billing and row-level security.
- *
- * The manager handles:
- * - Tenant creation with Stripe billing integration
- * - Secure tenant deletion with data cleanup
- * - Active tenant switching with JWT token management
- * - User permission validation for all operations
- *
- * All operations are performed within the authenticated user context and
- * respect tenant ownership and permission rules.
- *
- * @example
- * ```typescript
- * const tenantManager = new TenantManger(omnibaseClient);
- *
- * // Create a new tenant
- * const tenant = await tenantManager.createTenant({
- *   name: 'Acme Corp',
- *   billing_email: 'billing@acme.com',
- *   user_id: 'user_123'
- * });
- *
- * // Switch to the new tenant
- * await tenantManager.switchActiveTenant(tenant.data.tenant.id);
- *
- * // Delete tenant (owner only)
- * await tenantManager.deleteTenant(tenant.data.tenant.id);
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Management
- */
-declare class TenantManger {
-    private omnibaseClient;
-    /**
-     * Creates a new TenantManger instance
-     *
-     * Initializes the manager with the provided Omnibase client for making
-     * authenticated API requests to tenant management endpoints.
-     *
-     * @param omnibaseClient - Configured Omnibase client instance
-     *
-     * @group Tenant Management
-     */
-    constructor(omnibaseClient: OmnibaseClient);
-    /**
-     * Creates a new tenant in the multi-tenant system
-     *
-     * Establishes a new tenant with integrated Stripe billing setup and assigns
-     * the specified user as the tenant owner. The operation creates the necessary
-     * database records and returns a JWT token that enables Row-Level Security
-     * access to the tenant's isolated data.
-     *
-     * The function automatically handles Stripe customer creation for billing
-     * integration and sets up the initial tenant configuration. The returned
-     * token should be stored securely for subsequent API calls.
-     *
-     * @param tenantData - Configuration object for the new tenant
-     * @param tenantData.name - Display name for the tenant organization
-     * @param tenantData.billing_email - Email address for Stripe billing notifications
-     * @param tenantData.user_id - Unique identifier of the user who will own this tenant
-     *
-     * @returns Promise resolving to the created tenant with authentication token
-     *
-     * @throws {Error} When required fields (name, user_id) are missing or empty
-     * @throws {Error} When the API request fails due to network issues
-     * @throws {Error} When the server returns an error response (4xx, 5xx status codes)
-     *
-     * @example
-     * ```typescript
-     * const newTenant = await tenantManager.createTenant({
-     *   name: 'Acme Corporation',
-     *   billing_email: 'billing@acme.com',
-     *   user_id: 'user_123'
-     * });
-     *
-     * console.log(`Tenant created: ${newTenant.data.tenant.id}`);
-     * ```
-     *
-     * @since 0.6.0
-     * @public
-     * @group Tenant Management
-     */
-    createTenant(tenantData: CreateTenantRequest): Promise<CreateTenantResponse>;
-    /**
-     * Permanently deletes a tenant and all associated data
-     *
-     * ⚠️ **WARNING: This operation is irreversible and will permanently delete:**
-     * - The tenant record and all metadata
-     * - All user memberships and invitations for this tenant
-     * - All tenant-specific data protected by row-level security
-     * - Any tenant-related billing information
-     * - All tenant configuration and settings
-     *
-     * **Access Control:**
-     * Only tenant owners can delete a tenant. This operation requires:
-     * - User must be authenticated
-     * - User must have 'owner' role for the specified tenant
-     * - Tenant must exist and be accessible to the user
-     *
-     * **Security Considerations:**
-     * - All tenant data is immediately and permanently removed
-     * - Other tenant members lose access immediately
-     * - Any active sessions for this tenant are invalidated
-     * - Billing subscriptions are cancelled (if applicable)
-     * - Audit logs for deletion are maintained for compliance
-     *
-     * @returns Promise resolving to a confirmation message
-     *
-     * @throws {Error} When the tenantId parameter is missing or empty
-     * @throws {Error} When the user is not authenticated
-     * @throws {Error} When the user is not an owner of the specified tenant
-     * @throws {Error} When the tenant doesn't exist or is not accessible
-     * @throws {Error} When the API request fails due to network issues
-     * @throws {Error} When the server returns an error response (4xx, 5xx status codes)
-     *
-     * @example
-     * ```typescript
-     * // Always confirm before deleting
-     * const userConfirmed = confirm(
-     *   'Are you sure you want to delete this tenant? This action cannot be undone.'
-     * );
-     *
-     * if (userConfirmed) {
-     *   try {
-     *     const result = await tenantManager.deleteTenant();
-     *     console.log(result.data.message);
-     *
-     *     // Redirect user away from deleted tenant
-     *     window.location.href = '/dashboard';
-     *   } catch (error) {
-     *     console.error('Failed to delete tenant:', error);
-     *   }
-     * }
-     * ```
-     *
-     * @since 0.6.0
-     * @public
-     * @group Tenant Management
-     */
-    deleteTenant(): Promise<DeleteTenantResponse>;
-    /**
-     * Switches the user's active tenant context
-     *
-     * Changes the user's active tenant to the specified tenant ID, updating
-     * their authentication context and permissions. This function is essential
-     * for multi-tenant applications where users belong to multiple tenants
-     * and need to switch between them.
-     *
-     * The function performs several operations:
-     * - Validates that the user has access to the specified tenant
-     * - Updates the user's active tenant in their session
-     * - Generates a new JWT token with updated tenant claims
-     * - Updates any cached tenant-specific data
-     *
-     * After switching tenants, all subsequent API calls will be made within
-     * the context of the new active tenant, with row-level security policies
-     * applied accordingly. The new JWT token should be used for all future
-     * authenticated requests.
-     *
-     * @param tenantId - The ID of the tenant to switch to (must be a tenant the user belongs to)
-     *
-     * @returns Promise resolving to a new JWT token and success confirmation
-     *
-     * @throws {Error} When the tenantId parameter is missing or empty
-     * @throws {Error} When the user doesn't have access to the specified tenant
-     * @throws {Error} When the user is not authenticated
-     * @throws {Error} When the specified tenant doesn't exist
-     * @throws {Error} When the API request fails due to network issues
-     * @throws {Error} When the server returns an error response (4xx, 5xx status codes)
-     *
-     * @example
-     * ```typescript
-     * const result = await tenantManager.switchActiveTenant('tenant_xyz789');
-     *
-     * // Store the new token for future requests
-     * console.log(`Switched to tenant. New token: ${result.data.token}`);
-     *
-     * // Now all API calls will be in the context of tenant_xyz789
-     * const tenantData = await getCurrentTenantData();
-     * ```
-     *
-     * @since 0.6.0
-     * @public
-     * @group Tenant Management
-     */
-    switchActiveTenant(tenantId: string): Promise<SwitchActiveTenantResponse>;
-}
-
-/**
- * Active subscription data returned from the API
- *
- * Represents a tenant's active Stripe subscription with config-based price IDs
- * instead of raw Stripe IDs. Includes legacy price detection for historical
- * billing configurations.
- *
- * @example
- * ```typescript
- * const subscription: TenantSubscription = {
- *   subscription_id: 'sub_1234567890',
- *   config_price_id: 'price_pro_monthly',
- *   status: 'active',
- *   is_legacy_price: false,
- *   current_period_end: 1735416000
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Subscriptions
- */
-type TenantSubscription = {
-    /** Stripe subscription ID */
-    subscription_id: string;
-    /** Config-based price ID from your billing configuration */
-    config_price_id: string;
-    /** Subscription status (active, trialing, past_due) */
-    status: string;
-    /** Whether this price is from a legacy billing configuration */
-    is_legacy_price: boolean;
-    /** Unix timestamp when the current billing period ends */
-    current_period_end: number;
-};
-/**
- * Response structure for getting active subscriptions
- *
- * @since 0.6.0
- * @public
- * @group Tenant Subscriptions
- */
-type GetActiveSubscriptionsResponse = ApiResponse<TenantSubscription[]>;
-/**
- * Billing status information for a tenant
- *
- * Indicates whether the tenant has valid billing information configured
- * in their Stripe customer account.
- *
- * @example
- * ```typescript
- * const status: BillingStatus = {
- *   has_billing_info: true,
- *   is_active: true
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Subscriptions
- */
-type BillingStatus = {
-    /** Whether the tenant has payment method(s) configured */
-    has_billing_info: boolean;
-    /** Whether the billing information is active and valid */
-    is_active: boolean;
-};
-/**
- * Response structure for billing status check
- *
- * @since 0.6.0
- * @public
- * @group Tenant Subscriptions
- */
-type GetBillingStatusResponse = ApiResponse<BillingStatus>;
-/**
- * Tenant subscription and billing management
- *
- * Provides access to the active tenant's Stripe subscriptions and billing
- * status. All operations are automatically scoped to the user's currently
- * active tenant via session authentication.
- *
- * Key features:
- * - View all active subscriptions with config-based price IDs
- * - Legacy price detection for historical billing configurations
- * - Billing status verification (payment method availability)
- * - Automatic tenant scoping via session context
- *
- * @example
- * ```typescript
- * const subscriptionManager = new TenantSubscriptionManager(omnibaseClient);
- *
- * // Get all active subscriptions for the current tenant
- * const subscriptions = await subscriptionManager.getActive();
- * console.log(`Active subscriptions: ${subscriptions.data.length}`);
- *
- * // Check if tenant has billing configured
- * const status = await subscriptionManager.getBillingStatus();
- * if (!status.data.has_billing_info) {
- *   console.log('Please add a payment method');
- * }
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Subscriptions
- */
-declare class TenantSubscriptionManager {
-    private omnibaseClient;
-    /**
-     * Creates a new TenantSubscriptionManager instance
-     *
-     * @param omnibaseClient - Configured Omnibase client instance
-     *
-     * @group Tenant Subscriptions
-     */
-    constructor(omnibaseClient: OmnibaseClient);
-    /**
-     * Get all active subscriptions for the current tenant
-     *
-     * Retrieves all active Stripe subscriptions associated with the user's
-     * currently active tenant. Returns subscriptions with config-based price IDs
-     * instead of raw Stripe IDs, making it easier to match against your billing
-     * configuration.
-     *
-     * The endpoint automatically:
-     * - Fetches subscriptions from Stripe API
-     * - Maps Stripe price IDs to your config price IDs
-     * - Checks both current and historical price mappings
-     * - Flags legacy prices from old billing configurations
-     * - Filters to only active/trialing/past_due subscriptions
-     *
-     * Returns an empty array if:
-     * - Tenant has no Stripe customer ID configured
-     * - Tenant has no active subscriptions
-     * - User is not authenticated
-     *
-     * @returns Promise resolving to array of active subscriptions
-     *
-     * @throws {Error} When the user is not authenticated
-     * @throws {Error} When the API request fails due to network issues
-     * @throws {Error} When the server returns an error response (4xx, 5xx)
-     *
-     * @example
-     * ```typescript
-     * const response = await subscriptionManager.getActive();
-     *
-     * if (response.data.length === 0) {
-     *   console.log('No active subscriptions');
-     * } else {
-     *   response.data.forEach(sub => {
-     *     console.log(`Plan: ${sub.config_price_id}`);
-     *     console.log(`Status: ${sub.status}`);
-     *     if (sub.is_legacy_price) {
-     *       console.log('⚠️ Using legacy pricing');
-     *     }
-     *   });
-     * }
-     * ```
-     *
-     * @since 0.6.0
-     * @public
-     * @group Tenant Subscriptions
-     */
-    getActive(): Promise<GetActiveSubscriptionsResponse>;
-    /**
-     * Check if the current tenant has billing information configured
-     *
-     * Verifies whether the tenant has valid payment methods attached to their
-     * Stripe customer account. This is useful for:
-     * - Showing billing setup prompts
-     * - Gating premium features behind payment method requirement
-     * - Displaying billing status indicators in UI
-     * - Determining if customer portal access should be shown
-     *
-     * The check verifies:
-     * - Default payment source (card, bank account, etc.)
-     * - Default payment method in invoice settings
-     * - Whether the payment method is valid and active
-     *
-     * Returns `false` if:
-     * - Tenant has no Stripe customer ID
-     * - No payment methods are configured
-     * - User is not authenticated
-     *
-     * @returns Promise resolving to billing status information
-     *
-     * @throws {Error} When the user is not authenticated
-     * @throws {Error} When the API request fails due to network issues
-     * @throws {Error} When the server returns an error response (4xx, 5xx)
-     *
-     * @example
-     * ```typescript
-     * const response = await subscriptionManager.getBillingStatus();
-     *
-     * if (!response.data.has_billing_info) {
-     *   // Show billing setup prompt
-     *   showBillingSetupModal();
-     * } else if (!response.data.is_active) {
-     *   // Payment method exists but may be expired/invalid
-     *   showPaymentMethodUpdatePrompt();
-     * } else {
-     *   // All good - show customer portal link
-     *   showManageBillingButton();
-     * }
-     * ```
-     *
-     * @since 0.6.0
-     * @public
-     * @group Tenant Subscriptions
-     */
-    getBillingStatus(): Promise<GetBillingStatusResponse>;
-}
-
-/**
- * Response structure for a tenant user
- *
- * Represents a user's information within a tenant, including their
- * identification details and assigned role.
- *
- * @example
- * ```typescript
- * const user: TenantUser = {
- *   user_id: 'user_abc123',
- *   first_name: 'John',
- *   last_name: 'Doe',
- *   email: 'john@example.com',
- *   role: 'admin'
- * };
- * ```
- *
- * @since 1.0.0
- * @public
- * @group Tenant User Management
- */
-type TenantUser = {
-    /** Unique identifier for the user */
-    user_id: string;
-    /** User's first name */
-    first_name: string;
-    /** User's last name */
-    last_name: string;
-    /** User's email address */
-    email: string;
-    /** User's role within the tenant */
-    role: string;
-};
-/**
- * Response from fetching all users in a tenant
- *
- * This type represents the API response structure returned when fetching
- * the list of all users in the active tenant.
- *
- * @since 1.0.0
- * @public
- * @group Tenant User Management
- */
-type GetAllUsersResponse = ApiResponse<TenantUser[]>;
-/**
- * Request parameters for updating a user's role within a tenant
- *
- * This interface defines the data required to change a user's role in the active tenant.
- * The operation requires appropriate permissions (typically admin or owner role) and will
- * fail if the requesting user doesn't have sufficient privileges.
- *
- * @example
- * ```typescript
- * const request: UpdateTenantUserRoleRequest = {
- *   user_id: 'user_abc123',
- *   role: 'admin'
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant User Management
- */
-type UpdateTenantUserRoleRequest = {
-    /** New role to assign to the user (e.g., 'admin', 'member', 'viewer') */
-    role: string;
-    /** ID of the user whose role is being updated */
-    user_id: string;
-};
-/**
- * Response from updating a user's role within a tenant
- *
- * This type represents the API response structure returned after successfully
- * updating a user's role in the tenant.
- *
- * @since 1.0.0
- * @public
- * @group Tenant User Management
- */
-type UpdateTenantUserRoleResponse = ApiResponse<{
-    /** Confirmation message describing the role update */
-    message: string;
-}>;
-/**
- * Request parameters for removing a user from a tenant
- *
- * This interface defines the data required to remove a user from the active tenant.
- * The operation requires appropriate permissions and will fail if the user doesn't
- * have the necessary rights to remove users from the tenant.
- *
- * @example
- * ```typescript
- * const request: RemoveUserRequest = {
- *   user_id: 'user_abc123'
- * };
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant User Management
- */
-type RemoveUserRequest = {
-    /** ID of the user being removed from the tenant */
-    user_id: string;
-};
-/**
- * Manager for tenant user operations
- *
- * This class provides methods for managing users within a tenant, including
- * removing users from the active tenant. All operations are performed within
- * the context of the authenticated user and respect tenant-level permissions.
- *
- * User removal operations require appropriate permissions (typically admin or owner
- * role) and will fail if the requesting user doesn't have sufficient privileges.
- *
- * @example
- * ```typescript
- * import { OmnibaseClient } from '@omnibase/core-js';
- *
- * const client = new OmnibaseClient({ apiKey: 'your-api-key' });
- * const userManager = client.tenants.user;
- *
- * // Remove a user from the active tenant
- * await userManager.remove({ user_id: 'user_123' });
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant User Management
- */
-declare class TenantUserManager {
-    private omnibaseClient;
-    /**
-     * Creates a new tenant user manager
-     *
-     * @param omnibaseClient - Configured OmnibaseClient instance for API communication
-     *
-     * @group Tenant User Management
-     */
-    constructor(omnibaseClient: OmnibaseClient);
-    /**
-     * Retrieves all users in the active tenant
-     *
-     * This method fetches a list of all users who are members of the current active tenant,
-     * including their basic information (name, email) and assigned role. The operation
-     * requires the requesting user to have appropriate permissions to view tenant users
-     * (typically requires `view_users` permission).
-     *
-     * The returned list includes all tenant members regardless of their role, ordered by
-     * when they joined the tenant (newest first).
-     *
-     * @returns Promise resolving to an array of tenant users with their details
-     *
-     * @throws {Error} When the API request fails (includes status code and error details)
-     * @throws {Error} When the user doesn't have permission to view users
-     * @throws {Error} When the user is not authenticated or no active tenant is set
-     *
-     * @example
-     * ```typescript
-     * // Fetch all users in the active tenant
-     * try {
-     *   const result = await userManager.getAll();
-     *   console.log(`Found ${result.data.length} users`);
-     *
-     *   result.data.forEach(user => {
-     *     console.log(`${user.first_name} ${user.last_name} (${user.email}) - ${user.role}`);
-     *   });
-     * } catch (error) {
-     *   if (error.message.includes('403')) {
-     *     console.error('Insufficient permissions to view users');
-     *   } else {
-     *     console.error('Failed to fetch users:', error);
-     *   }
-     * }
-     * ```
-     *
-     * @since 1.0.0
-     * @public
-     * @group Tenant User Management
-     */
-    getAll(): Promise<GetAllUsersResponse>;
-    /**
-     * Removes a user from the active tenant
-     *
-     * This method removes a specified user from the current active tenant. The operation
-     * requires the requesting user to have appropriate permissions (admin or owner role).
-     * The user being removed will lose access to the tenant and all its resources.
-     *
-     * Note: You cannot remove yourself from a tenant using this method. To leave a tenant,
-     * use the appropriate leave or delete tenant operations instead.
-     *
-     * @param data - Request data containing the user ID to remove
-     * @param data.user_id - ID of the user to remove from the tenant
-     *
-     * @returns Promise resolving to an API response confirming the removal
-     *
-     * @throws {Error} When user_id is not provided
-     * @throws {Error} When the API request fails (includes status code and error details)
-     * @throws {Error} When the user doesn't have permission to remove users
-     * @throws {Error} When the specified user is not a member of the tenant
-     *
-     * @example
-     * ```typescript
-     * // Remove a user from the active tenant
-     * try {
-     *   await userManager.remove({ user_id: 'user_abc123' });
-     *   console.log('User removed successfully');
-     * } catch (error) {
-     *   if (error.message.includes('403')) {
-     *     console.error('Insufficient permissions to remove user');
-     *   } else if (error.message.includes('404')) {
-     *     console.error('User not found in tenant');
-     *   } else {
-     *     console.error('Failed to remove user:', error);
-     *   }
-     * }
-     * ```
-     *
-     * @since 0.6.0
-     * @public
-     * @group Tenant User Management
-     */
-    remove(data: RemoveUserRequest): Promise<ApiResponse<"">>;
-    /**
-     * Updates a user's role within the active tenant
-     *
-     * This method changes the role of a specified user in the current active tenant. The operation
-     * requires the requesting user to have appropriate permissions (typically admin or owner role).
-     * Role updates take effect immediately and affect the user's permissions and access rights
-     * within the tenant.
-     *
-     * Common roles include 'admin', 'member', and 'viewer', but the exact roles available depend
-     * on your tenant's configuration. Changing a user's role will modify their ability to perform
-     * various operations within the tenant.
-     *
-     * @param data - Request data containing the user ID and new role
-     * @param data.user_id - ID of the user whose role is being updated
-     * @param data.role - New role to assign to the user
-     *
-     * @returns Promise resolving to an API response confirming the role update
-     *
-     * @throws {Error} When user_id or role is not provided
-     * @throws {Error} When the API request fails (includes status code and error details)
-     * @throws {Error} When the user doesn't have permission to update roles
-     * @throws {Error} When the specified user is not a member of the tenant
-     * @throws {Error} When the specified role is invalid or not allowed
-     *
-     * @example
-     * ```typescript
-     * // Update a user's role to admin
-     * try {
-     *   const result = await userManager.updateRole({
-     *     user_id: 'user_abc123',
-     *     role: 'admin'
-     *   });
-     *   console.log('Role updated successfully:', result.data.message);
-     * } catch (error) {
-     *   if (error.message.includes('403')) {
-     *     console.error('Insufficient permissions to update roles');
-     *   } else if (error.message.includes('404')) {
-     *     console.error('User not found in tenant');
-     *   } else {
-     *     console.error('Failed to update role:', error);
-     *   }
-     * }
-     * ```
-     *
-     * @since 0.6.0
-     * @public
-     * @group Tenant User Management
-     */
-    updateRole(data: UpdateTenantUserRoleRequest): Promise<UpdateTenantUserRoleResponse>;
-}
-
-/**
- * Main tenant management handler
- *
- * This is the primary entry point for all tenant-related operations in the
- * Omnibase SDK. It provides a unified interface to tenant management,
- * user management, and invitation functionality through dedicated manager instances.
- *
- * The handler follows the composition pattern, combining specialized managers
- * for different aspects of tenant functionality:
- * - `manage`: Core tenant operations (create, delete, switch)
- * - `invites`: User invitation management (create, accept)
- * - `user`: Tenant user operations (remove, update role)
- *
- * All operations are performed within the context of the authenticated user
- * and respect tenant-level permissions and row-level security policies.
- *
- * @example
- * ```typescript
- * import { OmnibaseClient } from '@omnibase/core-js';
- * import { TenantHandler } from '@omnibase/core-js/tenants';
- *
- * const client = new OmnibaseClient({ apiKey: 'your-api-key' });
- * const tenantHandler = new TenantHandler(client);
- *
- * // Create a new tenant
- * const tenant = await tenantHandler.manage.createTenant({
- *   name: 'My Company',
- *   billing_email: 'billing@company.com',
- *   user_id: 'user_123'
- * });
- *
- * // Invite users to the tenant
- * const invite = await tenantHandler.invites.create({
- *   email: 'colleague@company.com',
- *   role: 'member',
- *   invite_url: 'https://yourapp.com/accept-invite'
- * });
- *
- * // Switch to the new tenant
- * await tenantHandler.manage.switchActiveTenant(tenant.data.tenant.id);
- * ```
- *
- * @since 0.6.0
- * @public
- * @group Tenant Management
- */
-declare class TenantHandler {
-    /**
-     * Creates a new TenantHandler instance
-     *
-     * Initializes the handler with the provided Omnibase client and sets up
-     * the specialized manager instances for tenant and invitation operations.
-     * The client is used for all underlying HTTP requests and authentication.
-     *
-     * @param omnibaseClient - Configured Omnibase client instance
-     *
-     * @example
-     * ```typescript
-     * const client = new OmnibaseClient({
-     *   apiKey: 'your-api-key',
-     *   baseURL: 'https://api.yourapp.com'
-     * });
-     * const tenantHandler = new TenantHandler(client);
-     * ```
-     *
-     * @group Tenant Management
-     */
-    constructor(omnibaseClient: OmnibaseClient);
-    /**
-     * Tenant user management operations
-     *
-     * Provides access to operations for managing users within tenants, including
-     * removing users from the active tenant. All operations respect user permissions
-     * and tenant ownership rules.
-     *
-     * @example
-     * ```typescript
-     * // Remove a user from the active tenant
-     * await tenantHandler.user.remove({ user_id: 'user_123' });
-     * ```
-     *
-     * @since 0.6.0
-     * @group Tenant Management
-     */
-    readonly user: TenantUserManager;
-    /**
-     * Core tenant management operations
-     *
-     * Provides access to tenant lifecycle operations including creation,
-     * deletion, and active tenant switching. All operations respect user
-     * permissions and tenant ownership rules.
-     *
-     * @example
-     * ```typescript
-     * // Create a new tenant
-     * const tenant = await tenantHandler.manage.createTenant({
-     *   name: 'New Company',
-     *   billing_email: 'billing@newcompany.com',
-     *   user_id: 'user_456'
-     * });
-     *
-     * // Switch to the tenant
-     * await tenantHandler.manage.switchActiveTenant(tenant.data.tenant.id);
-     *
-     * // Delete the tenant (owner only)
-     * await tenantHandler.manage.deleteTenant(tenant.data.tenant.id);
-     * ```
-     */
-    readonly manage: TenantManger;
-    /**
-     * Tenant invitation management operations
-     *
-     * Provides access to user invitation functionality including creating
-     * invitations for new users and accepting existing invitations.
-     * Supports role-based access control and secure token-based workflows.
-     *
-     * @example
-     * ```typescript
-     * // Create an invitation
-     * const invite = await tenantHandler.invites.create({
-     *   email: 'newuser@company.com',
-     *   role: 'admin',
-     *   invite_url: 'https://yourapp.com/accept-invite'
-     * });
-     *
-     * // Accept an invitation (from the invited user's session)
-     * const result = await tenantHandler.invites.accept('invite_token_xyz');
-     * ```
-     */
-    readonly invites: TenantInviteManager;
-    /**
-     * Tenant subscription and billing management
-     *
-     * Provides access to subscription data and billing status for the
-     * active tenant, including legacy price detection and payment method
-     * verification. All operations are automatically scoped to the user's
-     * currently active tenant.
-     *
-     * @example
-     * ```typescript
-     * // Get active subscriptions
-     * const subs = await tenantHandler.subscriptions.getActive();
-     *
-     * // Check billing status
-     * const status = await tenantHandler.subscriptions.getBillingStatus();
-     * if (!status.data.has_billing_info) {
-     *   console.log('No payment method configured');
-     * }
-     * ```
-     *
-     * @since 0.6.0
-     * @group Tenant Management
-     */
-    readonly subscriptions: TenantSubscriptionManager;
-}
-
-type OmnibaseClientConfig = {
-    api_url: string;
-    fetch?: (endpoint: string, options: RequestInit) => Promise<Response>;
-};
-declare class OmnibaseClient {
-    private config;
-    constructor(config: OmnibaseClientConfig);
-    /**
-     * Main payment handler for all payment-related operations
-     *
-     * This class serves as the central coordinator for all payment functionality,
-     * providing access to checkout sessions, billing configuration, customer portals,
-     * and usage tracking. It handles the low-level HTTP communication with the
-     * payment API and delegates specific operations to specialized managers.
-     *
-     * The handler automatically manages authentication, request formatting, and
-     * provides a consistent interface across all payment operations.
-     *
-     * @example
-     * ```typescript
-     * // Create a checkout session (mode auto-detected from price)
-     * const checkout = await omnibase.payments.checkout.createSession({
-     *   price_id: 'price_123',
-     *   success_url: 'https://app.com/success',
-     *   cancel_url: 'https://app.com/cancel'
-     * });
-     *
-     * // Get available products
-     * const products = await omnibase.payments.config.getAvailableProducts();
-     * ```
-     */
-    readonly payments: PaymentHandler;
-    /**
-     * Main tenant management handler
-     *
-     * This is the primary entry point for all tenant-related operations in the
-     * Omnibase SDK. It provides a unified interface to tenant management,
-     * user management, and invitation functionality through dedicated manager instances.
-     *
-     * The handler follows the composition pattern, combining specialized managers
-     * for different aspects of tenant functionality:
-     * - `manage`: Core tenant operations (create, delete, switch)
-     * - `invites`: User invitation management (create, accept)
-     * - `user`: Tenant user operations (remove, update role)
-     *
-     * All operations are performed within the context of the authenticated user
-     * and respect tenant-level permissions and row-level security policies.
-     *
-     * @example
-     * ```typescript
-     * // Create a new tenant
-     * const tenant = await omnibase.tenants.manage.createTenant({
-     *   name: 'My Company',
-     *   billing_email: 'billing@company.com',
-     *   user_id: 'user_123'
-     * });
-     *
-     * // Invite users to the tenant
-     * const invite = await omnibase.tenants.invites.create({
-     *   email: 'colleague@company.com',
-     *   role: 'member',
-     *   invite_url: 'https://yourapp.com/accept-invite'
-     * });
-     *
-     * // Switch to the new tenant
-     * await omnibase.tenants.manage.switchActiveTenant(tenant.data.tenant.id);
-     * ```
-     *
-     * @since 0.6.0
-     * @public
-     * @group Tenant Management
-     */
-    readonly tenants: TenantHandler;
-    /**
-     * Client for managing permissions and relationships using Ory Keto
-     *
-     * This client provides access to Ory Keto's permission system, allowing you to
-     * create, manage, and check relationships between subjects and objects. It handles
-     * both read operations (permission checks) and write operations (relationship management).
-     *
-     * The client automatically configures separate endpoints for read and write operations
-     * to optimize performance and security by following Ory Keto's recommended architecture.
-     *
-     * @example
-     * ```typescript
-     * // Check if a user can view a tenant
-     * const canView = await omnibase.permissions.permissions.checkPermission(
-     *   undefined,
-     *   {
-     *     namespace: 'Tenant',
-     *     object: 'tenant_123',
-     *     relation: 'view',
-     *     subjectId: 'user_456'
-     *   }
-     * );
-     *
-     * if (canView.data.allowed) {
-     *   console.log('User can view the tenant');
-     * }
-     *
-     * // Create a relationship making a user an owner of a tenant
-     * await omnibase.permissions.relationships.createRelationship(
-     *   undefined,
-     *   {
-     *     namespace: 'Tenant',
-     *     object: 'tenant_123',
-     *     relation: 'owners',
-     *     subjectId: 'user_456'
-     *   }
-     * );
-     * ```
-     *
-     * @since 0.6.0
-     * @public
-     * @group Permissions
-     */
-    readonly permissions: PermissionsClient;
-    /**
-     * Storage client for file upload/download operations
-     *
-     * @example
-     * ```typescript
-     * // Upload with metadata
-     * await omnibase.storage.bucket('documents').upload(
-     *   'report.pdf',
-     *   file,
-     *   { metadata: { department: 'engineering' } }
-     * );
-     * ```
-     */
-    storage: StorageClient;
-    fetch(endpoint: string, options?: RequestInit): Promise<Response>;
-}
-
-export { type AssignRoleRequest as A, type BillingStatus as B, type CreateRoleRequest as C, CheckoutManager, type CheckoutOptions, ConfigManager, type CreateCheckoutResponse, type CreateCustomerPortalResponse, type DownloadResult as D, type GetActiveSubscriptionsResponse as G, type NamespaceDefinition as N, type OmnibaseClientConfig as O, PermissionsClient as P, PaymentHandler, PortalManager, type PortalOptions, type Price, type PriceDisplay, type PriceLimit, type PriceUI, type Product, type ProductUI, type ProductWithPricingUI, RolesHandler as R, StorageClient as S, type StripeConfigResponse, type StripeConfiguration, TenantHandler as T, type Tier, type UpdateRoleRequest as U, UsageManager, type UsageOptions, type Role as a, type UploadOptions as b, type UploadResult as c, type AcceptTenantInviteRequest as d, type AcceptTenantInviteResponse as e, type CreateTenantUserInviteResponse as f, type TenantInvite as g, type CreateTenantUserInviteRequest as h, TenantInviteManager as i, type SwitchActiveTenantResponse as j, type DeleteTenantResponse as k, type CreateTenantResponse as l, type Tenant as m, type CreateTenantRequest as n, TenantManger as o, type TenantSubscription as p, type GetBillingStatusResponse as q, TenantSubscriptionManager as r, OmnibaseClient as s, type ApiResponse as t };