@wopr-network/platform-core 1.67.1 → 1.69.0

package/dist/server/routes/provision-webhook.js

@@ -0,0 +1,160 @@
+/**
+ * Provision webhook routes — instance lifecycle management.
+ *
+ * POST /create  — spin up a new container and configure it
+ * POST /destroy — tear down a container
+ * PUT  /budget  — update a container's spending budget
+ *
+ * Extracted from product-specific implementations into platform-core so
+ * every product gets the same timing-safe auth and DI-based fleet access
+ * without copy-pasting.
+ *
+ * All env var names are generic (no product-specific prefixes).
+ */
+import { timingSafeEqual } from "node:crypto";
+import { Hono } from "hono";
+// ---------------------------------------------------------------------------
+// Timing-safe secret validation (same pattern as crypto-webhook)
+// ---------------------------------------------------------------------------
+function assertSecret(authHeader, secret) {
+    if (!authHeader?.startsWith("Bearer "))
+        return false;
+    const token = authHeader.slice("Bearer ".length).trim();
+    if (token.length !== secret.length)
+        return false;
+    return timingSafeEqual(Buffer.from(token), Buffer.from(secret));
+}
+// ---------------------------------------------------------------------------
+// Route factory
+// ---------------------------------------------------------------------------
+/**
+ * Create the provision webhook Hono sub-app.
+ *
+ * Mount it at `/api/provision` (or wherever the product prefers).
+ *
+ * ```ts
+ * app.route("/api/provision", createProvisionWebhookRoutes(container, config));
+ * ```
+ */
+export function createProvisionWebhookRoutes(container, config) {
+    const app = new Hono();
+    // ------------------------------------------------------------------
+    // POST /create — create a new managed instance
+    // ------------------------------------------------------------------
+    app.post("/create", async (c) => {
+        if (!assertSecret(c.req.header("authorization"), config.provisionSecret)) {
+            return c.json({ error: "Unauthorized" }, 401);
+        }
+        if (!container.fleet) {
+            return c.json({ error: "Fleet management not configured" }, 501);
+        }
+        const body = await c.req.json();
+        const { tenantId, subdomain } = body;
+        if (!tenantId || !subdomain) {
+            return c.json({ error: "Missing required fields: tenantId, subdomain" }, 422);
+        }
+        // Billing gate — require positive credit balance before provisioning
+        const balance = await container.creditLedger.balance(tenantId);
+        if (typeof balance === "object" && "isZero" in balance) {
+            const bal = balance;
+            if (bal.isZero() || bal.isNegative()) {
+                return c.json({ error: "Insufficient credits: add funds before creating an instance" }, 402);
+            }
+        }
+        // Instance limit gate
+        const { profileStore, manager: fleet, proxy } = container.fleet;
+        if (config.maxInstancesPerTenant > 0) {
+            const profiles = await profileStore.list();
+            const tenantInstances = profiles.filter((p) => p.tenantId === tenantId);
+            if (tenantInstances.length >= config.maxInstancesPerTenant) {
+                return c.json({ error: `Instance limit reached: maximum ${config.maxInstancesPerTenant} per tenant` }, 403);
+            }
+        }
+        // Create the Docker container
+        const instance = await fleet.create({
+            tenantId,
+            name: subdomain,
+            description: `Managed instance for ${subdomain}`,
+            image: config.instanceImage,
+            env: {
+                PORT: String(config.containerPort),
+                PROVISION_SECRET: config.provisionSecret,
+                HOSTED_MODE: "true",
+                DEPLOYMENT_MODE: "hosted_proxy",
+                DEPLOYMENT_EXPOSURE: "private",
+                MIGRATION_AUTO_APPLY: "true",
+            },
+            restartPolicy: "unless-stopped",
+            releaseChannel: "stable",
+            updatePolicy: "manual",
+        });
+        // Register proxy route — container name must match FleetManager naming convention
+        const prefix = config.containerPrefix ?? "wopr";
+        const containerName = `${prefix}-${subdomain}`;
+        await proxy.addRoute({
+            instanceId: instance.id,
+            subdomain,
+            upstreamHost: containerName,
+            upstreamPort: config.containerPort,
+            healthy: true,
+        });
+        return c.json({
+            ok: true,
+            instanceId: instance.id,
+            subdomain,
+            containerUrl: `http://${containerName}:${config.containerPort}`,
+        }, 201);
+    });
+    // ------------------------------------------------------------------
+    // POST /destroy — tear down a managed instance
+    // ------------------------------------------------------------------
+    app.post("/destroy", async (c) => {
+        if (!assertSecret(c.req.header("authorization"), config.provisionSecret)) {
+            return c.json({ error: "Unauthorized" }, 401);
+        }
+        if (!container.fleet) {
+            return c.json({ error: "Fleet management not configured" }, 501);
+        }
+        const body = await c.req.json();
+        const { instanceId } = body;
+        if (!instanceId) {
+            return c.json({ error: "Missing required field: instanceId" }, 422);
+        }
+        const { manager: fleet, proxy, serviceKeyRepo } = container.fleet;
+        // Revoke gateway service key
+        await serviceKeyRepo.revokeByInstance(instanceId);
+        // Remove the Docker container
+        try {
+            await fleet.remove(instanceId);
+        }
+        catch {
+            // Container may already be gone — continue cleanup
+        }
+        // Remove proxy route
+        proxy.removeRoute(instanceId);
+        return c.json({ ok: true });
+    });
+    // ------------------------------------------------------------------
+    // PUT /budget — update a container's spending budget
+    // ------------------------------------------------------------------
+    app.put("/budget", async (c) => {
+        if (!assertSecret(c.req.header("authorization"), config.provisionSecret)) {
+            return c.json({ error: "Unauthorized" }, 401);
+        }
+        if (!container.fleet) {
+            return c.json({ error: "Fleet management not configured" }, 501);
+        }
+        const body = await c.req.json();
+        const { instanceId, tenantEntityId, budgetCents } = body;
+        if (!instanceId || !tenantEntityId || budgetCents === undefined) {
+            return c.json({ error: "Missing required fields: instanceId, tenantEntityId, budgetCents" }, 422);
+        }
+        const { manager: fleet } = container.fleet;
+        const status = await fleet.status(instanceId);
+        if (status.state !== "running") {
+            return c.json({ error: "Instance not running" }, 503);
+        }
+        return c.json({ ok: true, instanceId, budgetCents });
+    });
+    return app;
+}

package/dist/server/routes/stripe-webhook.d.ts

@@ -0,0 +1,10 @@
+import { Hono } from "hono";
+import type { PlatformContainer } from "../container.js";
+/**
+ * Stripe webhook route factory.
+ *
+ * Delegates to `container.stripe.processor.handleWebhook()` which
+ * calls `stripe.webhooks.constructEvent()` internally for signature
+ * verification.
+ */
+export declare function createStripeWebhookRoutes(container: PlatformContainer): Hono;

package/dist/server/routes/stripe-webhook.js

@@ -0,0 +1,29 @@
+import { Hono } from "hono";
+/**
+ * Stripe webhook route factory.
+ *
+ * Delegates to `container.stripe.processor.handleWebhook()` which
+ * calls `stripe.webhooks.constructEvent()` internally for signature
+ * verification.
+ */
+export function createStripeWebhookRoutes(container) {
+    const routes = new Hono();
+    routes.post("/", async (c) => {
+        if (!container.stripe) {
+            return c.json({ error: "Stripe not configured" }, 501);
+        }
+        const rawBody = Buffer.from(await c.req.arrayBuffer());
+        const sig = c.req.header("stripe-signature");
+        if (!sig) {
+            return c.json({ error: "Missing stripe-signature header" }, 400);
+        }
+        try {
+            const result = await container.stripe.processor.handleWebhook(rawBody, sig);
+            return c.json({ ok: true, result }, 200);
+        }
+        catch {
+            return c.json({ error: "Webhook processing failed" }, 400);
+        }
+    });
+    return routes;
+}

package/dist/server/test-container.d.ts

@@ -0,0 +1,15 @@
+/**
+ * createTestContainer — builds a PlatformContainer with sensible mock
+ * defaults for unit tests. All feature sub-containers default to null.
+ * Core services get minimal stubs that satisfy their interfaces.
+ *
+ * Usage:
+ *   const c = createTestContainer();
+ *   const c2 = createTestContainer({ creditLedger: myCustomLedger });
+ */
+import type { PlatformContainer } from "./container.js";
+/**
+ * Create a PlatformContainer pre-filled with no-op stubs.
+ * Pass overrides for any field you need to customize in your test.
+ */
+export declare function createTestContainer(overrides?: Partial<PlatformContainer>): PlatformContainer;

package/dist/server/test-container.js

@@ -0,0 +1,103 @@
+/**
+ * createTestContainer — builds a PlatformContainer with sensible mock
+ * defaults for unit tests. All feature sub-containers default to null.
+ * Core services get minimal stubs that satisfy their interfaces.
+ *
+ * Usage:
+ *   const c = createTestContainer();
+ *   const c2 = createTestContainer({ creditLedger: myCustomLedger });
+ */
+// ---------------------------------------------------------------------------
+// Stub factories (satisfy interface contracts with no-op implementations)
+// ---------------------------------------------------------------------------
+function stubLedger() {
+    const zero = 0;
+    const emptyEntry = {};
+    return {
+        post: async () => emptyEntry,
+        credit: async () => emptyEntry,
+        debit: async () => emptyEntry,
+        balance: async () => zero,
+        hasReferenceId: async () => false,
+        history: async () => [],
+        tenantsWithBalance: async () => [],
+        memberUsage: async () => [],
+        lifetimeSpend: async () => zero,
+        lifetimeSpendBatch: async () => new Map(),
+        expiredCredits: async () => [],
+        trialBalance: async () => ({ balanced: true }),
+        accountBalance: async () => zero,
+        seedSystemAccounts: async () => { },
+        existsByReferenceIdLike: async () => false,
+        sumPurchasesForPeriod: async () => zero,
+        getActiveTenantIdsInWindow: async () => [],
+        debitCapped: async () => null,
+    };
+}
+function stubOrgMemberRepo() {
+    return {
+        listMembers: async () => [],
+        addMember: async () => { },
+        updateMemberRole: async () => { },
+        removeMember: async () => { },
+        findMember: async () => null,
+        countAdminsAndOwners: async () => 0,
+        listInvites: async () => [],
+        createInvite: async () => { },
+        findInviteById: async () => null,
+        findInviteByToken: async () => null,
+        deleteInvite: async () => { },
+        deleteAllMembers: async () => { },
+        deleteAllInvites: async () => { },
+        listOrgsByUser: async () => [],
+        markInviteAccepted: async () => { },
+    };
+}
+function stubUserRoleRepo() {
+    return {
+        getTenantIdByUserId: async () => null,
+        grantRole: async () => { },
+        revokeRole: async () => false,
+        listRolesByUser: async () => [],
+        listUsersByRole: async () => [],
+        isPlatformAdmin: async () => false,
+    };
+}
+function stubProductConfig() {
+    return {
+        product: {
+            slug: "test",
+            name: "Test Product",
+        },
+        navItems: [],
+        domains: [],
+        features: null,
+        fleet: null,
+        billing: null,
+    };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Create a PlatformContainer pre-filled with no-op stubs.
+ * Pass overrides for any field you need to customize in your test.
+ */
+export function createTestContainer(overrides) {
+    const defaults = {
+        db: {},
+        pool: { end: async () => { } },
+        productConfig: stubProductConfig(),
+        creditLedger: stubLedger(),
+        orgMemberRepo: stubOrgMemberRepo(),
+        orgService: {},
+        userRoleRepo: stubUserRoleRepo(),
+        // Feature sub-containers default to null (not enabled)
+        fleet: null,
+        crypto: null,
+        stripe: null,
+        gateway: null,
+        hotPool: null,
+    };
+    return { ...defaults, ...overrides };
+}

package/dist/trpc/auth-helpers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared auth helper factories for tRPC routers.
+ *
+ * These helpers can be constructed with explicit deps (for container-based DI)
+ * instead of relying on module-level singletons.
+ */
+import type { IOrgMemberRepository } from "../tenancy/org-member-repository.js";
+/**
+ * Creates an assertOrgAdminOrOwner function closed over the given repository.
+ *
+ * Usage:
+ * ```ts
+ * const assertOrgAdmin = createAssertOrgAdminOrOwner(container.orgMemberRepo);
+ * await assertOrgAdmin(tenantId, userId);
+ * ```
+ */
+export declare function createAssertOrgAdminOrOwner(orgMemberRepo: IOrgMemberRepository): (tenantId: string, userId: string) => Promise<void>;

package/dist/trpc/auth-helpers.js

@@ -0,0 +1,26 @@
+/**
+ * Shared auth helper factories for tRPC routers.
+ *
+ * These helpers can be constructed with explicit deps (for container-based DI)
+ * instead of relying on module-level singletons.
+ */
+import { TRPCError } from "@trpc/server";
+/**
+ * Creates an assertOrgAdminOrOwner function closed over the given repository.
+ *
+ * Usage:
+ * ```ts
+ * const assertOrgAdmin = createAssertOrgAdminOrOwner(container.orgMemberRepo);
+ * await assertOrgAdmin(tenantId, userId);
+ * ```
+ */
+export function createAssertOrgAdminOrOwner(orgMemberRepo) {
+    return async function assertOrgAdminOrOwner(tenantId, userId) {
+        if (tenantId === userId)
+            return;
+        const member = await orgMemberRepo.findMember(tenantId, userId);
+        if (!member || (member.role !== "owner" && member.role !== "admin")) {
+            throw new TRPCError({ code: "FORBIDDEN", message: "Organization admin access required" });
+        }
+    };
+}

package/dist/trpc/container-factories.d.ts

@@ -0,0 +1,300 @@
+/**
+ * Container-based tRPC router factories.
+ *
+ * Each function accepts a PlatformContainer (plus any extra deps not yet on
+ * the container) and returns a tRPC router by delegating to the existing
+ * factory functions. This provides a single-call DI entry point for products
+ * that have migrated to the container pattern, while the existing factory
+ * functions and setter-based API remain fully functional for products that
+ * haven't migrated yet.
+ */
+import type { INotificationTemplateRepository } from "../email/notification-template-repository.js";
+import type { RolloutOrchestrator } from "../fleet/rollout-orchestrator.js";
+import type { ITenantUpdateConfigRepository } from "../fleet/tenant-update-config-repository.js";
+import type { ProductConfigService } from "../product-config/service.js";
+import type { PlatformContainer } from "../server/container.js";
+import { type OrgRemovePaymentMethodDeps } from "./org-remove-payment-method-router.js";
+/**
+ * Wire the PlatformContainer's orgMemberRepo into the tRPC middleware layer.
+ *
+ * This replaces the manual `setTrpcOrgMemberRepo()` call. Products using the
+ * container call this once at boot; the setter-based API remains for products
+ * that haven't migrated yet.
+ */
+export declare function initTrpcFromContainer(container: PlatformContainer): void;
+/**
+ * Create the admin fleet-update router from a container.
+ *
+ * Requires additional fleet-specific deps (orchestrator + config repo) that
+ * are constructed at boot when fleet is enabled and are not yet on the
+ * PlatformContainer itself.
+ */
+export declare function createAdminFleetUpdateRouterFromContainer(_container: PlatformContainer, getOrchestrator: () => RolloutOrchestrator, getConfigRepo: () => ITenantUpdateConfigRepository): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("./init.js").TRPCContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    rolloutStatus: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            isRolling: boolean;
+        };
+        meta: object;
+    }>;
+    forceRollout: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            triggered: boolean;
+        };
+        meta: object;
+    }>;
+    listTenantConfigs: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: import("../fleet/tenant-update-config-repository.js").TenantUpdateConfig[];
+        meta: object;
+    }>;
+    setTenantConfig: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tenantId: string;
+            mode: "manual" | "auto";
+            preferredHourUtc?: number | undefined;
+        };
+        output: void;
+        meta: object;
+    }>;
+}>>;
+/**
+ * Create the fleet-update-config router from a container.
+ *
+ * Requires the tenant-update-config repository getter (fleet-specific dep
+ * not yet on PlatformContainer).
+ */
+export declare function createFleetUpdateConfigRouterFromContainer(_container: PlatformContainer, getConfigRepo: () => ITenantUpdateConfigRepository): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("./init.js").TRPCContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getUpdateConfig: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            tenantId: string;
+        };
+        output: import("../fleet/tenant-update-config-repository.js").TenantUpdateConfig | null;
+        meta: object;
+    }>;
+    setUpdateConfig: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            tenantId: string;
+            mode: "manual" | "auto";
+            preferredHourUtc?: number | undefined;
+        };
+        output: void;
+        meta: object;
+    }>;
+}>>;
+/**
+ * Create the notification-template router from a container.
+ *
+ * Requires a getter for the notification-template repository (not yet on
+ * PlatformContainer).
+ */
+export declare function createNotificationTemplateRouterFromContainer(_container: PlatformContainer, getRepo: () => INotificationTemplateRepository): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("./init.js").TRPCContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    listTemplates: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: import("../email/notification-repository-types.js").NotificationTemplateRow[];
+        meta: object;
+    }>;
+    getTemplate: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            name: string;
+        };
+        output: import("../email/notification-repository-types.js").NotificationTemplateRow | null;
+        meta: object;
+    }>;
+    updateTemplate: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            name: string;
+            subject?: string | undefined;
+            htmlBody?: string | undefined;
+            textBody?: string | undefined;
+            description?: string | undefined;
+            active?: boolean | undefined;
+        };
+        output: void;
+        meta: object;
+    }>;
+    previewTemplate: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            subject: string;
+            htmlBody: string;
+            textBody: string;
+            data: Record<string, unknown>;
+        };
+        output: {
+            subject: string;
+            html: string;
+            text: string;
+        };
+        meta: object;
+    }>;
+    seedDefaults: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            inserted: number;
+            total: number;
+        };
+        meta: object;
+    }>;
+}>>;
+/**
+ * Create the org-remove-payment-method router from a container.
+ *
+ * The container's StripeServices.processor is typed narrowly (webhook-only),
+ * so this still requires the full OrgRemovePaymentMethodDeps to be supplied
+ * until the container's Stripe sub-container is widened to include
+ * IPaymentProcessor.
+ */
+export declare function createOrgRemovePaymentMethodRouterFromContainer(_container: PlatformContainer, getDeps: () => OrgRemovePaymentMethodDeps): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("./init.js").TRPCContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    orgRemovePaymentMethod: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            orgId: string;
+            paymentMethodId: string;
+        };
+        output: {
+            removed: boolean;
+        };
+        meta: object;
+    }>;
+}>>;
+/**
+ * Create the product-config router from a container.
+ *
+ * Requires a getter for ProductConfigService and the product slug, both of
+ * which are product-specific and not on PlatformContainer.
+ */
+export declare function createProductConfigRouterFromContainer(_container: PlatformContainer, getService: () => ProductConfigService, productSlug: string): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("./init.js").TRPCContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getBrandConfig: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: import("../product-config/repository-types.js").ProductBrandConfig | null;
+        meta: object;
+    }>;
+    getNavItems: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            label: string;
+            href: string;
+        }[];
+        meta: object;
+    }>;
+    admin: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: import("./init.js").TRPCContext;
+        meta: object;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: false;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        get: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: import("../product-config/repository-types.js").ProductConfig | null;
+            meta: object;
+        }>;
+        listAll: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: import("../product-config/repository-types.js").ProductConfig[];
+            meta: object;
+        }>;
+        updateBrand: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                brandName?: string | undefined;
+                productName?: string | undefined;
+                tagline?: string | undefined;
+                domain?: string | undefined;
+                appDomain?: string | undefined;
+                cookieDomain?: string | undefined;
+                companyLegal?: string | undefined;
+                priceLabel?: string | undefined;
+                defaultImage?: string | undefined;
+                emailSupport?: string | undefined;
+                emailPrivacy?: string | undefined;
+                emailLegal?: string | undefined;
+                fromEmail?: string | undefined;
+                homePath?: string | undefined;
+                storagePrefix?: string | undefined;
+            };
+            output: void;
+            meta: object;
+        }>;
+        updateNavItems: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                label: string;
+                href: string;
+                sortOrder: number;
+                icon?: string | undefined;
+                requiresRole?: string | undefined;
+                enabled?: boolean | undefined;
+            }[];
+            output: void;
+            meta: object;
+        }>;
+        updateFeatures: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                chatEnabled?: boolean | undefined;
+                onboardingEnabled?: boolean | undefined;
+                onboardingDefaultModel?: string | undefined;
+                onboardingSystemPrompt?: string | undefined;
+                onboardingMaxCredits?: number | undefined;
+                onboardingWelcomeMsg?: string | undefined;
+                sharedModuleBilling?: boolean | undefined;
+                sharedModuleMonitoring?: boolean | undefined;
+                sharedModuleAnalytics?: boolean | undefined;
+            };
+            output: void;
+            meta: object;
+        }>;
+        updateFleet: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                containerImage?: string | undefined;
+                containerPort?: number | undefined;
+                lifecycle?: "managed" | "ephemeral" | undefined;
+                billingModel?: "monthly" | "per_use" | "none" | undefined;
+                maxInstances?: number | undefined;
+                imageAllowlist?: string[] | undefined;
+                dockerNetwork?: string | undefined;
+                placementStrategy?: string | undefined;
+                fleetDataDir?: string | undefined;
+            };
+            output: void;
+            meta: object;
+        }>;
+        updateBilling: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                stripePublishableKey?: string | undefined;
+                stripeSecretKey?: string | undefined;
+                stripeWebhookSecret?: string | undefined;
+                creditPrices?: Record<string, number> | undefined;
+                affiliateBaseUrl?: string | undefined;
+                affiliateMatchRate?: number | undefined;
+                affiliateMaxCap?: number | undefined;
+                dividendRate?: number | undefined;
+                marginConfig?: unknown;
+            };
+            output: void;
+            meta: object;
+        }>;
+    }>>;
+}>>;