@openrails/billing-ui 0.241.0 → 0.243.0

package/dist/admin/hooks/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;

package/dist/admin/index.d.ts

@@ -0,0 +1,5 @@
+export { BillingAdmin } from './billing-admin';
+export type { BillingAdminProps, BillingAdminAuth, BillingAdminMerchant, BillingAdminNavigation, BillingAdminResource, BillingAdminSettingsTab, } from './types';
+export { BillingCustomerSummary, billingConfirmWarnings, billingPermissionHelp, useBillingAdminAccess, } from './summary';
+export type { BillingCustomerSummaryProps } from './summary';
+export { billingAdminMessages } from './messages';

package/dist/admin/layouts/app-layout.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from 'react';
+export declare function AppLayout({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/admin/lib/api/client.d.ts

@@ -0,0 +1,64 @@
+import { BillingAdminAuth, BillingAdminResource } from '../../types';
+import { OpenRailsErrorCode } from '../../../client/generated/error-codes';
+import { ListPage } from '../../../client/generated/wire';
+export interface ApiErrorBody {
+    error?: {
+        type?: string;
+        code?: OpenRailsErrorCode;
+        message?: string;
+        param?: string;
+        metadata?: Record<string, unknown>;
+    };
+}
+export declare class ApiError extends Error {
+    status: number;
+    type?: string;
+    code?: OpenRailsErrorCode;
+    param?: string;
+    metadata?: Record<string, unknown>;
+    constructor(status: number, body: ApiErrorBody | null, fallback: string);
+    get isPermissionDenied(): boolean;
+    get revisionMismatch(): boolean;
+    get merchantConfigReadOnly(): boolean;
+}
+export interface RequestOptions {
+    method?: string;
+    body?: unknown;
+    rawBody?: string;
+    headers?: Record<string, string>;
+    query?: Record<string, string | number | boolean | undefined>;
+    signal?: AbortSignal;
+}
+export interface ApiResponse<T> {
+    status: number;
+    body: T;
+}
+export interface PageRequest {
+    limit?: number;
+    cursor?: string;
+}
+export declare function collectCursorPages<T>(loadPage: (cursor?: string) => Promise<ListPage<T>>, signal?: AbortSignal): Promise<T[]>;
+export interface CursorEnvelope<T> {
+    data: T[];
+    next_cursor: string | null;
+}
+export interface AdminClientOptions {
+    namespace?: string;
+    isCurrent?: () => boolean;
+    baseUrl: string;
+    auth: BillingAdminAuth;
+    merchant?: {
+        id: string;
+        slug: string;
+    };
+    exchange?: Omit<BillingAdminResource, "group">;
+}
+/** One immutable transport per component and selected merchant. */
+export declare function createAdminClient(options: AdminClientOptions): {
+    namespace: string | undefined;
+    api: <T>(path: string, opts?: RequestOptions) => Promise<T>;
+    apiResponse: <T>(path: string, opts?: RequestOptions) => Promise<ApiResponse<T>>;
+    selectedMerchant: () => string | undefined;
+    queryRoot: (requested?: string) => readonly [...string[], "merchant", string];
+};
+export type AdminClient = ReturnType<typeof createAdminClient>;

package/dist/admin/lib/api/copilot.d.ts

@@ -0,0 +1,6 @@
+import { AdminClient } from './client';
+import { CatalogAnswer } from '../../../client/generated/wire';
+export type { CatalogAnswer, CatalogDraft, NewPriceDraft, PriceChangeDraft, } from '../../../client/generated/wire';
+export declare function createCopilot(client: AdminClient): {
+    askCatalog: (question: string) => Promise<CatalogAnswer>;
+};

package/dist/admin/lib/api/credit-endpoints.d.ts

@@ -0,0 +1,8 @@
+import { AdminClient } from './client';
+import { CreditGrant, CreditGrantInput, BalanceTransaction, ListPage } from './credit-types';
+export declare function createCreditEndpoints(client: AdminClient): {
+    listCreditGrants: (customer: string, currency: string, limit: number, cursor: string, signal?: AbortSignal) => Promise<ListPage<CreditGrant>>;
+    createCreditGrant: (customer: string, body: CreditGrantInput) => Promise<CreditGrant>;
+    revokeCreditGrant: (grant: string, reason: string) => Promise<CreditGrant>;
+    listBalanceTransactions: (customer: string, currency: string, limit: number, cursor: string, signal?: AbortSignal) => Promise<ListPage<BalanceTransaction>>;
+};

package/dist/admin/lib/api/credit-types.d.ts

@@ -0,0 +1,9 @@
+export type { CreditGrant, BalanceTransaction, ListPage, } from '../../../client/generated/wire';
+export interface CreditGrantInput {
+    currency: string;
+    amount: string;
+    source: "admin";
+    source_id: string;
+    expires_at?: string;
+    description?: string;
+}

package/dist/admin/lib/api/endpoints.d.ts

@@ -0,0 +1,133 @@
+import { AdminClient, CursorEnvelope, PageRequest } from './client';
+import { AdminAccess, AlertWebhook, Allowance, CatalogApplicationReceipt, CreateAlertWebhookParams, CreatePSPParams, PSPRefresh, CreatePriceParams, Customer, ListPage, MerchantConfigurationState, Meter, PSP, Payment, PaymentAttempt, PaymentMethod, Price, PriceKeyMovement, Product, PublicConfig, RatePrice, Renewal, UpdateAlertWebhookParams, UpdateCustomerParams, UpdateMerchantConfigurationParams, UpdatePSPParams, UpdatePriceParams, UpdateProductParams } from '../../../client/generated/wire';
+import { CustomerEntitlement, Finding, PSPRoutingPreview, RawProductAccessGrant, PriceMigration, PriceMigrationCancel, PriceMigrationPreview, ChangeSubscriptionParams, SubscriptionChange, SubscriptionChangePreview } from './types';
+export interface ProductGrant {
+    productId: string;
+    hours?: number;
+    endsAt?: string;
+    reason?: "comp" | "staff";
+    note?: string;
+}
+export interface SubscriptionFilters {
+    status?: string;
+    dunning?: string;
+    rail?: string;
+    customer_id?: string;
+    price_id?: string;
+    expires_before?: string;
+    canceled_after?: string;
+    sort?: string;
+}
+export interface PaymentFilters {
+    customer_id?: string;
+    subscription_id?: string;
+    order_id?: string;
+    status?: Payment["status"];
+    rail?: string;
+    kind?: Payment["kind"];
+    transaction_id?: string;
+}
+export type AttemptFilters = Partial<Record<(typeof ATTEMPT_FILTERS)[number], string>>;
+export declare const ATTEMPT_FILTERS: readonly ["kind", "owner", "category", "reason", "response_code", "card_entry", "source", "observed_via", "avs_result", "cvv_result", "psp_id", "customer_id", "payment_id", "order_id", "subscription_id", "cycle_id", "since", "until"];
+export type CycleFilters = Partial<Record<(typeof CYCLE_FILTERS)[number], string>>;
+export declare const CYCLE_FILTERS: readonly ["owner", "first_outcome", "miss_reason", "outcome", "psp_id", "subscription_id", "due_since", "due_until"];
+export declare function filtersFrom<K extends string>(params: URLSearchParams, keys: readonly K[]): Partial<Record<K, string>>;
+export declare const REFUNDABLE_RAILS: string[];
+export declare const PAGE_MAX = 500;
+export interface ProductRequest {
+    key: string;
+    display_name: string;
+    description: string;
+    tier_group?: string;
+    tier_rank?: number;
+    entitlements?: string[];
+}
+export interface UsageMeterRequest {
+    event_type: string;
+    value_property: string;
+    aggregation: "sum" | "count";
+    unit?: string;
+    group_by: Record<string, string>;
+    rate_card?: DefaultUsageRateCardRequest | null;
+    expected_revision?: number;
+}
+export interface DefaultUsageRateCardRequest {
+    product_id: string;
+    filter: Record<string, string[]>;
+    price: RatePrice;
+    allowance?: Allowance;
+}
+export type { CatalogApplicationReceipt } from '../../../client/generated/wire';
+export declare function createEndpoints(client: AdminClient): {
+    listCustomers: (search: string, limit: number, cursor: string, signal?: AbortSignal) => Promise<ListPage<Customer>>;
+    getCustomer: (customerId: string, signal?: AbortSignal) => Promise<Customer>;
+    listCustomerEntitlements: (customerId: string, page: PageRequest, signal?: AbortSignal) => Promise<ListPage<CustomerEntitlement>>;
+    listCustomerProductAccess: (customerId: string, page: PageRequest, signal?: AbortSignal) => Promise<ListPage<RawProductAccessGrant>>;
+    listCustomerPaymentMethods: (customerId: string, page: PageRequest, signal?: AbortSignal) => Promise<ListPage<PaymentMethod>>;
+    grantProductAccess: (customerId: string, grant: ProductGrant) => Promise<{
+        items: RawProductAccessGrant[];
+    }>;
+    revokeProductAccess: (grantId: string, reason: string) => Promise<void>;
+    listSubscriptions: (filters: SubscriptionFilters, limit: number, cursor?: string, signal?: AbortSignal) => Promise<CursorEnvelope<import('./types').RawSubscription>>;
+    getSubscription: (id: string, signal?: AbortSignal) => Promise<import('./types').RawSubscription>;
+    cancelSubscription: (id: string, reason: string, revokeAccess: boolean) => Promise<import('./types').RawSubscription>;
+    resumeSubscription: (id: string) => Promise<import('./types').RawSubscription>;
+    changeSubscriptionPaymentMethod: (id: string, paymentMethodId: string | null) => Promise<import('./types').RawSubscription>;
+    previewSubscriptionChange: (id: string, change: ChangeSubscriptionParams) => Promise<SubscriptionChangePreview>;
+    changeSubscription: (id: string, change: ChangeSubscriptionParams, idempotencyKey: string) => Promise<SubscriptionChange>;
+    listPayments: (filters: PaymentFilters, page: PageRequest, signal?: AbortSignal) => Promise<ListPage<Payment>>;
+    getPayment: (id: string, signal?: AbortSignal) => Promise<Payment>;
+    refundPayment: (id: string, amount: string, reason: string, revokeAccess: boolean) => Promise<Payment>;
+    listPaymentAttempts: (filters: AttemptFilters, page: PageRequest, signal?: AbortSignal) => Promise<ListPage<PaymentAttempt>>;
+    getPaymentAttempt: (id: string, signal?: AbortSignal) => Promise<PaymentAttempt>;
+    listRenewals: (filters: CycleFilters, page: PageRequest, signal?: AbortSignal) => Promise<ListPage<Renewal>>;
+    getRenewal: (id: string, signal?: AbortSignal) => Promise<Renewal>;
+    listProducts: (limit: number, cursor?: string, archived?: boolean, signal?: AbortSignal) => Promise<ListPage<Product>>;
+    getProduct: (id: string, signal?: AbortSignal) => Promise<Product>;
+    createProduct: (body: ProductRequest) => Promise<Product>;
+    updateProduct: (id: string, body: UpdateProductParams) => Promise<Product>;
+    listUsageMeters: (limit?: number, cursor?: string, signal?: AbortSignal) => Promise<ListPage<Meter>>;
+    getUsageMeter: (key: string, signal?: AbortSignal) => Promise<Meter>;
+    putUsageMeter: (key: string, body: UsageMeterRequest) => Promise<Meter>;
+    putUsageMeterRateCard: (meter: Meter, rateCard: DefaultUsageRateCardRequest | null) => Promise<Meter>;
+    listPrices: (limit: number, cursor?: string, productId?: string, signal?: AbortSignal) => Promise<ListPage<Price>>;
+    createPrice: (body: CreatePriceParams) => Promise<Price>;
+    getPrice: (id: string, verify?: boolean, signal?: AbortSignal) => Promise<Price>;
+    getProductByKey: (productKey: string) => Promise<Product>;
+    updatePrice: (id: string, body: UpdatePriceParams) => Promise<Price>;
+    getPriceHistory: (priceId: string, signal?: AbortSignal) => Promise<ListPage<PriceKeyMovement>>;
+    previewPriceMigration: (productKey: string, priceKey: string) => Promise<PriceMigrationPreview>;
+    createPriceMigration: (productKey: string, priceKey: string, toPriceId: string, effectiveAt: string) => Promise<PriceMigration>;
+    listPriceMigrations: (productKey: string, priceKey: string, limit?: number, signal?: AbortSignal) => Promise<CursorEnvelope<PriceMigration>>;
+    cancelPriceMigration: (id: string) => Promise<PriceMigrationCancel>;
+    applyCatalog: (document: string, force?: boolean) => Promise<CatalogApplicationReceipt>;
+    refreshPSPs: () => Promise<PSPRefresh>;
+    listFindings: (filters: {
+        status?: string;
+        severity?: string;
+        type?: string;
+    }, limit: number, signal?: AbortSignal) => Promise<ListPage<Finding>>;
+    getFinding: (id: string) => Promise<Finding>;
+    resolveFinding: (id: string, outcome: "approve" | "ignore", notes: string) => Promise<{
+        finding: Finding;
+        execution?: Record<string, unknown>;
+    }>;
+    getMerchantConfiguration: (signal?: AbortSignal) => Promise<MerchantConfigurationState>;
+    updateMerchantConfiguration: (body: UpdateMerchantConfigurationParams) => Promise<MerchantConfigurationState>;
+    listPSPs: (signal?: AbortSignal) => Promise<ListPage<PSP>>;
+    listRails: (signal?: AbortSignal) => Promise<import('../../../client/generated/wire').RailDefinition[]>;
+    createPSP: (body: CreatePSPParams) => Promise<PSP>;
+    updatePSP: (id: string, body: UpdatePSPParams) => Promise<PSP>;
+    previewPSPRouting: (body: {
+        price_id: string;
+        country?: string;
+        psp?: string;
+    }, signal?: AbortSignal) => Promise<PSPRoutingPreview>;
+    getConfig: (signal?: AbortSignal) => Promise<PublicConfig>;
+    getAdminAccess: (signal?: AbortSignal) => Promise<AdminAccess>;
+    updateCustomer: (customerId: string, params: UpdateCustomerParams) => Promise<Customer>;
+    listWebhooks: (signal?: AbortSignal) => Promise<ListPage<AlertWebhook>>;
+    createWebhook: (body: CreateAlertWebhookParams) => Promise<AlertWebhook>;
+    updateWebhook: (id: string, body: UpdateAlertWebhookParams) => Promise<AlertWebhook>;
+    deleteWebhook: (id: string) => Promise<void>;
+};

package/dist/admin/lib/api/index.d.ts

@@ -0,0 +1,89 @@
+import { AdminClient } from './client';
+export declare function createAdminAPI(client: AdminClient): {
+    getInvoiceProfile: (customerId: string, signal?: AbortSignal) => Promise<import('../../../client/generated/wire').InvoiceProfile | null>;
+    putInvoiceProfile: (customerId: string, profile: import('../../../client/generated/wire').InvoiceProfile) => Promise<import('../../../client/generated/wire').InvoiceProfile | null>;
+    listOrders: (filters: import('./order-endpoints').OrderFilters, page: import('./client').PageRequest, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('../../../client/generated/wire').Order>>;
+    getOrder: (id: string, signal?: AbortSignal) => Promise<import('../../../client/generated/wire').Order>;
+    listOrderPayments: (id: string, page: import('./client').PageRequest, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('../../../client/generated/wire').Payment>>;
+    applyUsageAction: (request: import('./order-endpoints').UsageActionRequest) => Promise<import('../../../client/generated/wire').Order | import('../../../client/generated/wire').Payment>;
+    listCreditGrants: (customer: string, currency: string, limit: number, cursor: string, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('./credit-types').CreditGrant>>;
+    createCreditGrant: (customer: string, body: import('./credit-types').CreditGrantInput) => Promise<import('./credit-types').CreditGrant>;
+    revokeCreditGrant: (grant: string, reason: string) => Promise<import('./credit-types').CreditGrant>;
+    listBalanceTransactions: (customer: string, currency: string, limit: number, cursor: string, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('./credit-types').BalanceTransaction>>;
+    askCatalog: (question: string) => Promise<import('./copilot').CatalogAnswer>;
+    metricsQuery: (query: import('./metrics').MetricsQuery, signal?: AbortSignal) => Promise<import('./metrics').MetricsResult>;
+    getDashboard: (signal?: AbortSignal) => Promise<import('./metrics').Dashboard>;
+    putDashboard: (widgets: import('./metrics').Widget[]) => Promise<import('./metrics').Dashboard>;
+    listCustomers: (search: string, limit: number, cursor: string, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('../../../client/generated/wire').Customer>>;
+    getCustomer: (customerId: string, signal?: AbortSignal) => Promise<import('../../../client/generated/wire').Customer>;
+    listCustomerEntitlements: (customerId: string, page: import('./client').PageRequest, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('./types').CustomerEntitlement>>;
+    listCustomerProductAccess: (customerId: string, page: import('./client').PageRequest, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('./types').RawProductAccessGrant>>;
+    listCustomerPaymentMethods: (customerId: string, page: import('./client').PageRequest, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('../../../client/generated/wire').PaymentMethod>>;
+    grantProductAccess: (customerId: string, grant: import('./endpoints').ProductGrant) => Promise<{
+        items: import('./types').RawProductAccessGrant[];
+    }>;
+    revokeProductAccess: (grantId: string, reason: string) => Promise<void>;
+    listSubscriptions: (filters: import('./endpoints').SubscriptionFilters, limit: number, cursor?: string, signal?: AbortSignal) => Promise<import('./client').CursorEnvelope<import('./types').RawSubscription>>;
+    getSubscription: (id: string, signal?: AbortSignal) => Promise<import('./types').RawSubscription>;
+    cancelSubscription: (id: string, reason: string, revokeAccess: boolean) => Promise<import('./types').RawSubscription>;
+    resumeSubscription: (id: string) => Promise<import('./types').RawSubscription>;
+    changeSubscriptionPaymentMethod: (id: string, paymentMethodId: string | null) => Promise<import('./types').RawSubscription>;
+    previewSubscriptionChange: (id: string, change: import('./types').ChangeSubscriptionParams) => Promise<import('./types').SubscriptionChangePreview>;
+    changeSubscription: (id: string, change: import('./types').ChangeSubscriptionParams, idempotencyKey: string) => Promise<import('./types').SubscriptionChange>;
+    listPayments: (filters: import('./endpoints').PaymentFilters, page: import('./client').PageRequest, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('../../../client/generated/wire').Payment>>;
+    getPayment: (id: string, signal?: AbortSignal) => Promise<import('../../../client/generated/wire').Payment>;
+    refundPayment: (id: string, amount: string, reason: string, revokeAccess: boolean) => Promise<import('../../../client/generated/wire').Payment>;
+    listPaymentAttempts: (filters: import('./endpoints').AttemptFilters, page: import('./client').PageRequest, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('../../../client/generated/wire').PaymentAttempt>>;
+    getPaymentAttempt: (id: string, signal?: AbortSignal) => Promise<import('../../../client/generated/wire').PaymentAttempt>;
+    listRenewals: (filters: import('./endpoints').CycleFilters, page: import('./client').PageRequest, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('../../../client/generated/wire').Renewal>>;
+    getRenewal: (id: string, signal?: AbortSignal) => Promise<import('../../../client/generated/wire').Renewal>;
+    listProducts: (limit: number, cursor?: string, archived?: boolean, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('../../../client/generated/wire').Product>>;
+    getProduct: (id: string, signal?: AbortSignal) => Promise<import('../../../client/generated/wire').Product>;
+    createProduct: (body: import('./endpoints').ProductRequest) => Promise<import('../../../client/generated/wire').Product>;
+    updateProduct: (id: string, body: import('../../../client/generated/wire').UpdateProductParams) => Promise<import('../../../client/generated/wire').Product>;
+    listUsageMeters: (limit?: number, cursor?: string, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('../../../client/generated/wire').Meter>>;
+    getUsageMeter: (key: string, signal?: AbortSignal) => Promise<import('../../../client/generated/wire').Meter>;
+    putUsageMeter: (key: string, body: import('./endpoints').UsageMeterRequest) => Promise<import('../../../client/generated/wire').Meter>;
+    putUsageMeterRateCard: (meter: import('../../../client/generated/wire').Meter, rateCard: import('./endpoints').DefaultUsageRateCardRequest | null) => Promise<import('../../../client/generated/wire').Meter>;
+    listPrices: (limit: number, cursor?: string, productId?: string, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('../../../client/generated/wire').Price>>;
+    createPrice: (body: import('../../../client/generated/wire').CreatePriceParams) => Promise<import('../../../client/generated/wire').Price>;
+    getPrice: (id: string, verify?: boolean, signal?: AbortSignal) => Promise<import('../../../client/generated/wire').Price>;
+    getProductByKey: (productKey: string) => Promise<import('../../../client/generated/wire').Product>;
+    updatePrice: (id: string, body: import('../../../client/generated/wire').UpdatePriceParams) => Promise<import('../../../client/generated/wire').Price>;
+    getPriceHistory: (priceId: string, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('../../../client/generated/wire').PriceKeyMovement>>;
+    previewPriceMigration: (productKey: string, priceKey: string) => Promise<import('./types').PriceMigrationPreview>;
+    createPriceMigration: (productKey: string, priceKey: string, toPriceId: string, effectiveAt: string) => Promise<import('./types').PriceMigration>;
+    listPriceMigrations: (productKey: string, priceKey: string, limit?: number, signal?: AbortSignal) => Promise<import('./client').CursorEnvelope<import('./types').PriceMigration>>;
+    cancelPriceMigration: (id: string) => Promise<import('./types').PriceMigrationCancel>;
+    applyCatalog: (document: string, force?: boolean) => Promise<import('./endpoints').CatalogApplicationReceipt>;
+    refreshPSPs: () => Promise<import('../../../client/generated/wire').PSPRefresh>;
+    listFindings: (filters: {
+        status?: string;
+        severity?: string;
+        type?: string;
+    }, limit: number, signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('./types').Finding>>;
+    getFinding: (id: string) => Promise<import('./types').Finding>;
+    resolveFinding: (id: string, outcome: "approve" | "ignore", notes: string) => Promise<{
+        finding: import('./types').Finding;
+        execution?: Record<string, unknown>;
+    }>;
+    getMerchantConfiguration: (signal?: AbortSignal) => Promise<import('./types').MerchantConfigurationState>;
+    updateMerchantConfiguration: (body: import('../../../client/generated/wire').UpdateMerchantConfigurationParams) => Promise<import('./types').MerchantConfigurationState>;
+    listPSPs: (signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('./types').PSP>>;
+    listRails: (signal?: AbortSignal) => Promise<import('./types').RailDefinition[]>;
+    createPSP: (body: import('../../../client/generated/wire').CreatePSPParams) => Promise<import('./types').PSP>;
+    updatePSP: (id: string, body: import('../../../client/generated/wire').UpdatePSPParams) => Promise<import('./types').PSP>;
+    previewPSPRouting: (body: {
+        price_id: string;
+        country?: string;
+        psp?: string;
+    }, signal?: AbortSignal) => Promise<import('./types').PSPRoutingPreview>;
+    getConfig: (signal?: AbortSignal) => Promise<import('../../../client/generated/wire').PublicConfig>;
+    getAdminAccess: (signal?: AbortSignal) => Promise<import('../../../client/generated/wire').AdminAccess>;
+    updateCustomer: (customerId: string, params: import('../../../client/generated/wire').UpdateCustomerParams) => Promise<import('../../../client/generated/wire').Customer>;
+    listWebhooks: (signal?: AbortSignal) => Promise<import('./credit-types').ListPage<import('./types').AlertWebhook>>;
+    createWebhook: (body: import('../../../client/generated/wire').CreateAlertWebhookParams) => Promise<import('./types').AlertWebhook>;
+    updateWebhook: (id: string, body: import('../../../client/generated/wire').UpdateAlertWebhookParams) => Promise<import('./types').AlertWebhook>;
+    deleteWebhook: (id: string) => Promise<void>;
+};
+export type AdminAPI = ReturnType<typeof createAdminAPI>;

package/dist/admin/lib/api/invoice-profile-endpoints.d.ts

@@ -0,0 +1,6 @@
+import { createEndpoints } from './endpoints';
+import { InvoiceProfile } from '../../../client/generated/wire';
+export declare function createInvoiceProfileEndpoints(endpoints: ReturnType<typeof createEndpoints>): {
+    getInvoiceProfile: (customerId: string, signal?: AbortSignal) => Promise<InvoiceProfile | null>;
+    putInvoiceProfile: (customerId: string, profile: InvoiceProfile) => Promise<InvoiceProfile | null>;
+};

package/dist/admin/lib/api/metrics.d.ts

@@ -0,0 +1,68 @@
+import { AdminClient } from './client';
+export interface MetricsRange {
+    from?: string;
+    to?: string;
+    last?: string;
+}
+export interface OrderTerm {
+    measure?: string;
+    dimension?: string;
+    dir?: "asc" | "desc";
+}
+export interface MetricsQuery {
+    measures: string[];
+    by?: string[];
+    grain?: string;
+    range: MetricsRange;
+    filters?: Record<string, string[]>;
+    order?: OrderTerm[];
+    limit?: number;
+    compare?: "previous_period";
+}
+export interface MetricsColumn {
+    name: string;
+    kind: "time" | "dimension" | "measure";
+    unit?: string;
+}
+export type MetricsCell = string | number | null;
+export interface MetricsResult {
+    grain?: string;
+    range: {
+        from: string;
+        to: string;
+    };
+    columns: MetricsColumn[];
+    rows: MetricsCell[][];
+    compare_range?: {
+        from: string;
+        to: string;
+    };
+    compare_rows?: MetricsCell[][];
+}
+export type WidgetViz = "stat" | "line" | "area" | "bar" | "donut" | "table";
+export declare const WIDGET_VIZ: WidgetViz[];
+export interface WidgetGrid {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface Widget {
+    id: string;
+    title: string;
+    viz: WidgetViz;
+    query: MetricsQuery;
+    grid: WidgetGrid;
+    fixed_range: boolean;
+}
+export interface Dashboard {
+    widgets: Widget[];
+    is_default: boolean;
+    updated_at?: string;
+    updated_by?: string;
+}
+export declare function createMetrics(client: AdminClient): {
+    metricsQuery: (query: MetricsQuery, signal?: AbortSignal) => Promise<MetricsResult>;
+    getDashboard: (signal?: AbortSignal) => Promise<Dashboard>;
+    putDashboard: (widgets: Widget[]) => Promise<Dashboard>;
+};

package/dist/admin/lib/api/order-endpoints.d.ts

@@ -0,0 +1,21 @@
+import { AdminClient, PageRequest } from './client';
+import { ListPage, Order, Payment } from '../../../client/generated/wire';
+export interface OrderFilters {
+    customer_id?: string;
+    origin?: string;
+    status?: string;
+    overdue?: string;
+}
+export type UsageAction = "waive_balance" | "mark_uncollectible" | "record_payment";
+export interface UsageActionRequest {
+    id: string;
+    action: UsageAction;
+    amount?: string;
+    reference?: string;
+}
+export declare function createOrderEndpoints(client: AdminClient): {
+    listOrders: (filters: OrderFilters, page: PageRequest, signal?: AbortSignal) => Promise<ListPage<Order>>;
+    getOrder: (id: string, signal?: AbortSignal) => Promise<Order>;
+    listOrderPayments: (id: string, page: PageRequest, signal?: AbortSignal) => Promise<ListPage<Payment>>;
+    applyUsageAction: (request: UsageActionRequest) => Promise<Order | Payment>;
+};

package/dist/admin/lib/api/types.d.ts

@@ -0,0 +1,122 @@
+import { SubscriptionDunning } from '../../../client/generated/wire';
+export type SubscriptionStatus = "pending" | "active" | "past_due" | "awaiting_method" | "unverified" | "canceled";
+export type Rail = "nmi" | "ccbill" | "solana" | "stripe" | string;
+export interface RawSubscription {
+    id: string;
+    customer_id: string;
+    psp_id?: string;
+    product_id: string;
+    price_id: string;
+    scheduled_change?: import('../../../client/generated/wire').ScheduledChange | null;
+    quantity: number | null;
+    collection_policy?: string;
+    status: SubscriptionStatus;
+    started_at: string;
+    ended_at: string | null;
+    current_period_starts_at: string | null;
+    current_period_ends_at: string | null;
+    rail: Rail;
+    rail_subscription_id: string | null;
+    payment_method_id: string | null;
+    dunning: SubscriptionDunning | null;
+    cancel_type: string | null;
+    cancel_feedback: string | null;
+    canceled_at: string | null;
+    price?: RawPrice;
+    created_at: string;
+    updated_at: string;
+}
+export interface RawPrice {
+    id: string;
+    product_id?: string;
+    unit_amount?: string;
+    currency?: string;
+    archived?: boolean;
+    key?: string;
+    access_duration_hours?: number;
+    billing_interval_hours?: number;
+    [k: string]: unknown;
+}
+export interface CustomerEntitlement {
+    customer_id: string;
+    entitlement: string;
+    quantity: number | null;
+}
+export interface RawProductAccessGrant {
+    id: string;
+    customer_id?: string;
+    product_id: string;
+    product_key: string;
+    product_name: string;
+    source_type: string;
+    source_id: string;
+    payment_id?: string | null;
+    grant_reason?: string | null;
+    granted_by?: string | null;
+    note?: string | null;
+    status: string;
+    starts_at: string;
+    ends_at?: string | null;
+    revoked_at?: string | null;
+    revoke_reason?: string | null;
+}
+export interface Page<T> {
+    data: T[];
+    next_cursor: string | null;
+}
+export type AdminSubscription = RawSubscription;
+export type { ChangeSubscriptionParams, SubscriptionChange, SubscriptionChangePreview, } from '../../../client/generated/wire';
+export type UsageAggregation = "sum" | "count" | "max" | "min" | "unique_count" | "latest";
+export type UsagePriceModel = "per_unit" | "tiered" | "package";
+export type PSPRoutingSkip = "unknown_selector" | "ambiguous_selector" | "not_armed" | "credentials_missing" | "link_missing" | "mode_unsupported" | "posture_disarmed" | "service_unavailable" | "resolve_failed";
+export interface PSPRoutingCandidate {
+    psp: string;
+    rail: Rail;
+    skip: PSPRoutingSkip | null;
+}
+export interface PSPRoutingPreview {
+    policy: string;
+    rule: number | null;
+    psp: string | null;
+    rail: Rail | null;
+    mode: string | null;
+    candidates: PSPRoutingCandidate[];
+}
+export type { PriceMigration, PriceMigrationCancel, PriceMigrationPreview, ScheduledChange, } from '../../../client/generated/wire';
+export interface Recommendation {
+    action: string;
+    params?: Record<string, unknown>;
+}
+export interface Finding {
+    id: string;
+    provider: string | null;
+    psp_id?: string | null;
+    resource_type?: string | null;
+    resource_id?: string | null;
+    external_resource_id?: string | null;
+    field?: string | null;
+    openrails_value?: string | null;
+    external_value?: string | null;
+    finding_type: string;
+    subject_key: string;
+    severity: "critical" | "high" | "medium" | "low";
+    status: string;
+    requires_review?: boolean;
+    recommended_action?: string;
+    evidence?: Record<string, unknown>;
+    last_seen_at: string;
+    resolved_at?: string;
+    resolution?: string;
+    operator_notes?: string;
+    created_at: string;
+    updated_at: string;
+    recommendation?: Recommendation;
+}
+export interface FindingsGauges {
+    total_open: number;
+    orphaned_members: number;
+    freeloaders: number;
+    duplicate_coverage: number;
+}
+export type { AlertWebhook, MerchantConfigurationState, MerchantSettings, PSP, RailDefinition, } from '../../../client/generated/wire';
+export type AlertSeverity = "warning" | "critical";

package/dist/admin/lib/auth.d.ts

@@ -0,0 +1,6 @@
+export declare function useAuth(): {
+    merchants: import('..').BillingAdminMerchant[];
+    activeMerchant: import('..').BillingAdminMerchant | undefined;
+    selectMerchant: (slug: string) => void;
+};
+export declare function useSelectedMerchant(): string | undefined;

package/dist/admin/lib/capabilities.d.ts

@@ -0,0 +1,13 @@
+import { AdminAccess } from '../../client/generated/wire';
+export declare function useAccess(): AdminAccess | undefined;
+export declare function hasAnyArea(access: AdminAccess): boolean;
+export declare function useAdminArea(): boolean;
+export declare function useAdminUpdates(): boolean;
+export declare function useCatalogArea(): boolean;
+export declare function useMerchantConfigEdits(): boolean;
+export declare function useCatalogWrites(): boolean;
+export declare function useMerchantConfig(): boolean;
+export declare function useMerchantConfigUpdates(): boolean;
+export declare function useMetrics(): boolean;
+export declare function useDashboardLayout(): boolean;
+export declare function settingsTab(requested: string | null, config: boolean, admin: boolean, others?: string[]): string;

package/dist/admin/lib/chunk-error.d.ts

@@ -0,0 +1 @@
+export declare function isChunkLoadError(error: unknown): boolean;

package/dist/admin/lib/confirm.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+export interface ConfirmOptions {
+    title: string;
+    description?: React.ReactNode;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    tone?: "default" | "destructive";
+}
+export type Confirm = (options: ConfirmOptions) => Promise<boolean>;
+export declare const ConfirmContext: React.Context<Confirm | null>;
+export declare function useConfirm(): Confirm;

package/dist/admin/lib/credit-queries.d.ts

@@ -0,0 +1,23 @@
+import { AdminClient } from './api/client';
+import { AdminAPI } from './api';
+import { QueryClient } from '@tanstack/react-query';
+import { CreditGrantInput } from './api/credit-types';
+export declare const creditCustomerKey: (merchant: string, customer: string) => readonly ["merchant", string, "customers", string];
+export declare function createCreditQueries(client: AdminClient, api: AdminAPI): {
+    assertMerchant: (merchant: string) => void;
+    creditQueries: {
+        grants: (merchant: string, customer: string, currency: string, limit: number, cursor: string) => import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<import('./api/credit-types').ListPage<import('./api/credit-types').CreditGrant>, Error, import('./api/credit-types').ListPage<import('./api/credit-types').CreditGrant>, (string | number)[]>, "queryFn"> & {
+            queryFn?: import('@tanstack/react-query').QueryFunction<import('./api/credit-types').ListPage<import('./api/credit-types').CreditGrant>, (string | number)[], never> | undefined;
+        } & import('@tanstack/react-query').QueryKeyWithDataTag<(string | number)[], import('./api/credit-types').ListPage<import('./api/credit-types').CreditGrant>, Error>;
+        transactions: (merchant: string, customer: string, currency: string, limit: number, cursor: string) => import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<import('./api/credit-types').ListPage<import('./api/credit-types').BalanceTransaction>, Error, import('./api/credit-types').ListPage<import('./api/credit-types').BalanceTransaction>, (string | number)[]>, "queryFn"> & {
+            queryFn?: import('@tanstack/react-query').QueryFunction<import('./api/credit-types').ListPage<import('./api/credit-types').BalanceTransaction>, (string | number)[], never> | undefined;
+        } & import('@tanstack/react-query').QueryKeyWithDataTag<(string | number)[], import('./api/credit-types').ListPage<import('./api/credit-types').BalanceTransaction>, Error>;
+    };
+    creditMutations: {
+        grant: (client: QueryClient, merchant: string, customer: string) => Omit<import('@tanstack/react-query').UseMutationOptions<import('./api/credit-types').CreditGrant, Error, CreditGrantInput, unknown>, "mutationKey">;
+        revoke: (client: QueryClient, merchant: string, customer: string) => Omit<import('@tanstack/react-query').UseMutationOptions<import('./api/credit-types').CreditGrant, Error, {
+            grant: string;
+            reason: string;
+        }, unknown>, "mutationKey">;
+    };
+};

package/dist/admin/lib/csv.d.ts

@@ -0,0 +1,3 @@
+export declare function csvEscape(v: unknown): string;
+export declare function toCsv(header: string[], rows: unknown[][]): string;
+export declare function downloadCsv(filename: string, header: string[], rows: unknown[][]): void;