@fabriktor/fx 0.0.32 → 0.0.33

package/dist/src/jobs/jobs.js

@@ -0,0 +1,375 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+import { LocationTypePersistent, Pending, Started, Terminated, ZeroID, } from "@fabriktor/schema";
+import { errRequired, errValidation } from "../core/err.js";
+const msgJobIDRequired = "Job ID is required.";
+const msgLocationIDRequired = "Location ID is required.";
+const msgMemberIDRequired = "Member ID is required.";
+const msgJobLocationMismatch = "Job location does not match the provided parent location.";
+const msgJobMembersOutsideLocation = "All job members must belong to the parent location.";
+const msgProgramMembersOutsideLocation = "All program job members must belong to the parent location.";
+const msgForemanOutsideLocation = "Foreman must belong to the parent location.";
+const msgJobStartPast = "A past-dated job must be explicitly created as an immediate job.";
+const msgProgramStartPast = "Program start date must not be in the past.";
+const msgJobStartOutsideLocation = "Job start date must fall within the parent location time span.";
+const msgProgramStartOutsideLocation = "Program job start date must fall within the parent location time span.";
+const msgLocationMemberAssigned = "Cannot remove a location member while they are assigned to a non-terminated job in that location.";
+const msgDateInvalid = "Date contains an invalid UTC value.";
+const msgLocationRangeInvalid = "Location contains an invalid scheduled time span.";
+const msgTimezoneInvalid = "Program timezone is invalid.";
+export const JobProgramCreateMode = {
+    Scheduled: "scheduled",
+    Immediate: "immediate",
+};
+export class JobsFX {
+    jobs;
+    now;
+    constructor(opts) {
+        this.jobs = opts.jobs;
+        this.now = opts.now ?? (() => new globalThis.Date());
+    }
+    async createJob(opts) {
+        const location_id = requiredID(opts.location.id, "location", msgLocationIDRequired);
+        const foremen = normalizeIDs(opts.in.foremen);
+        const current_members = unionIDs(opts.in.current_members, foremen);
+        validateLocationMembers({
+            members: current_members,
+            location: opts.location,
+            field: "in",
+            msg: msgJobMembersOutsideLocation,
+        });
+        validateJobStart(opts, this.now());
+        const input = {
+            ...opts.in,
+            status: opts.start_immediately ? Started : Pending,
+            is_active: opts.start_immediately,
+            auto_start: opts.start_immediately ? true : opts.auto_start,
+            all_members: [],
+            current_members,
+            foremen,
+            location_id,
+            recurrent: false,
+        };
+        return await this.jobs.insertOneJob({
+            in: input,
+        });
+    }
+    async createJobProgram(opts) {
+        const job_location_id = requiredID(opts.location.id, "location", msgLocationIDRequired);
+        const job_foremen = normalizeIDs(opts.in.job_foremen);
+        const job_current_members = unionIDs(opts.in.job_current_members, job_foremen);
+        validateLocationMembers({
+            members: job_current_members,
+            location: opts.location,
+            field: "in",
+            msg: msgProgramMembersOutsideLocation,
+        });
+        const input = {
+            ...opts.in,
+            job_current_members,
+            job_foremen,
+            job_location_id,
+            current_occurrences: 0,
+        };
+        const now = this.now();
+        const current_day = isCurrentProgramDay(input, now);
+        validateProgramStart({
+            input,
+            location: opts.location,
+            now,
+            current_day,
+        });
+        if (current_day) {
+            await this.jobs.immediateJobFromProgram(input);
+            return {
+                mode: JobProgramCreateMode.Immediate,
+            };
+        }
+        const create = await this.jobs.insertOneJobProgram({
+            in: input,
+        });
+        return {
+            mode: JobProgramCreateMode.Scheduled,
+            create,
+        };
+    }
+    async findLocationOverlaps(opts) {
+        const input = {
+            start_date: {
+                y: opts.in.y,
+                m: opts.in.m,
+                d: opts.in.d,
+                h: opts.in.h,
+                min: opts.in.min,
+                tz: opts.in.tz,
+            },
+            end_date: {
+                y: opts.in.end_date.y,
+                m: opts.in.end_date.m,
+                d: opts.in.end_date.d,
+                h: opts.in.end_date.h,
+                min: opts.in.end_date.min,
+                tz: opts.in.end_date.tz,
+            },
+            source_id: resolvedID(opts.source_id) ?? ZeroID,
+            exclude_pending: opts.exclude_pending ?? false,
+            exclude_started: opts.exclude_started ?? false,
+            exclude_terminated: opts.exclude_terminated ?? false,
+        };
+        return await this.jobs.findOverlaps(input);
+    }
+    async addJobForeman(opts) {
+        const id = requiredID(opts.job.id, "job", msgJobIDRequired);
+        const location_id = requiredID(opts.location.id, "location", msgLocationIDRequired);
+        const job_location_id = opts.job.location_id.trim();
+        if (job_location_id !== location_id) {
+            throw errValidation({
+                field: "job",
+                msg: msgJobLocationMismatch,
+            });
+        }
+        const member_id = opts.member_id.trim();
+        if (member_id === "") {
+            throw errRequired({
+                field: "member_id",
+                msg: msgMemberIDRequired,
+            });
+        }
+        const location_members = new Set(normalizeIDs(opts.location.current_members));
+        if (!location_members.has(member_id)) {
+            throw errValidation({
+                field: "member_id",
+                msg: msgForemanOutsideLocation,
+            });
+        }
+        return await this.jobs.replaceOneJob({
+            id,
+            in: {
+                current_members: unionIDs(opts.job.current_members, [member_id]),
+                foremen: unionIDs(opts.job.foremen, [member_id]),
+            },
+        });
+    }
+    async removeJobMember(opts) {
+        const id = requiredID(opts.job.id, "job", msgJobIDRequired);
+        const member_id = opts.member_id.trim();
+        if (member_id === "") {
+            throw errRequired({
+                field: "member_id",
+                msg: msgMemberIDRequired,
+            });
+        }
+        return await this.jobs.replaceOneJob({
+            id,
+            in: {
+                current_members: withoutID(opts.job.current_members, member_id),
+            },
+        });
+    }
+    async setLocationMembers(opts) {
+        const id = requiredID(opts.location.id, "location", msgLocationIDRequired);
+        const current_members = normalizeIDs(opts.current_members);
+        const next = new Set(current_members);
+        const removed = normalizeIDs(opts.location.current_members).filter((member_id) => !next.has(member_id));
+        if (removed.length > 0) {
+            const out = await this.jobs.queryJobs({
+                query: {
+                    location_id: id,
+                },
+            });
+            const removed_set = new Set(removed);
+            for (const job of out.value ?? []) {
+                if (job.status === Terminated) {
+                    continue;
+                }
+                if (normalizeIDs(job.current_members).some((member_id) => removed_set.has(member_id))) {
+                    throw errValidation({
+                        field: "current_members",
+                        msg: msgLocationMemberAssigned,
+                    });
+                }
+            }
+        }
+        return await this.jobs.replaceOneLocation({
+            id,
+            in: {
+                current_members,
+            },
+        });
+    }
+}
+export function newJobsFX(opts) {
+    return new JobsFX(opts);
+}
+function validateLocationMembers(opts) {
+    const allowed = new Set(normalizeIDs(opts.location.current_members));
+    if (opts.members.some((member_id) => !allowed.has(member_id))) {
+        throw errValidation({
+            field: opts.field,
+            msg: opts.msg,
+        });
+    }
+}
+function validateJobStart(opts, now) {
+    const start_ms = utcMilliseconds(opts.in.utc, "in");
+    if (!opts.start_immediately && start_ms < now.getTime()) {
+        throw errValidation({
+            field: "in",
+            msg: msgJobStartPast,
+        });
+    }
+    validateLocationStart({
+        start_ms,
+        location: opts.location,
+        field: "in",
+        msg: msgJobStartOutsideLocation,
+    });
+}
+function validateProgramStart(opts) {
+    const start_ms = utcMilliseconds(opts.input.job_start_date.utc, "in");
+    if (!opts.current_day && start_ms < opts.now.getTime()) {
+        throw errValidation({
+            field: "in",
+            msg: msgProgramStartPast,
+        });
+    }
+    validateLocationStart({
+        start_ms,
+        location: opts.location,
+        field: "in",
+        msg: msgProgramStartOutsideLocation,
+    });
+}
+function validateLocationStart(opts) {
+    if (opts.location.type === LocationTypePersistent) {
+        return;
+    }
+    const location_start_ms = parsedUTC(opts.location.utc);
+    const location_end_ms = parsedUTC(opts.location.end_date.utc);
+    if (location_start_ms === undefined ||
+        location_end_ms === undefined ||
+        location_end_ms < location_start_ms) {
+        throw errValidation({
+            field: opts.field,
+            msg: msgLocationRangeInvalid,
+        });
+    }
+    if (opts.start_ms < location_start_ms || opts.start_ms > location_end_ms) {
+        throw errValidation({
+            field: opts.field,
+            msg: opts.msg,
+        });
+    }
+}
+function isCurrentProgramDay(input, now) {
+    const day = localDayParts(now, input.timezone);
+    if (day === undefined) {
+        throw errValidation({
+            field: "in",
+            msg: msgTimezoneInvalid,
+        });
+    }
+    return (input.job_start_date.y === day.y &&
+        input.job_start_date.m === day.m &&
+        input.job_start_date.d === day.d);
+}
+function localDayParts(now, timezone) {
+    const time_zone = timezone.trim();
+    if (time_zone === "") {
+        return undefined;
+    }
+    let parts;
+    try {
+        parts = new Intl.DateTimeFormat("en-CA", {
+            timeZone: time_zone,
+            year: "numeric",
+            month: "numeric",
+            day: "numeric",
+        }).formatToParts(now);
+    }
+    catch {
+        return undefined;
+    }
+    const y = datePart(parts, "year");
+    const m = datePart(parts, "month");
+    const d = datePart(parts, "day");
+    if (y === undefined || m === undefined || d === undefined) {
+        return undefined;
+    }
+    return {
+        y,
+        m,
+        d,
+    };
+}
+function datePart(parts, type) {
+    const raw = parts.find((part) => part.type === type)?.value;
+    if (raw === undefined) {
+        return undefined;
+    }
+    const out = Number.parseInt(raw, 10);
+    if (!Number.isFinite(out)) {
+        return undefined;
+    }
+    return out;
+}
+function utcMilliseconds(v, field) {
+    const out = parsedUTC(v);
+    if (out === undefined) {
+        throw errValidation({
+            field,
+            msg: msgDateInvalid,
+        });
+    }
+    return out;
+}
+function parsedUTC(v) {
+    const raw = v.trim();
+    if (raw === "") {
+        return undefined;
+    }
+    const out = globalThis.Date.parse(raw);
+    if (!Number.isFinite(out)) {
+        return undefined;
+    }
+    return out;
+}
+function requiredID(v, field, msg) {
+    const out = resolvedID(v);
+    if (out === undefined) {
+        throw errRequired({
+            field,
+            msg,
+        });
+    }
+    return out;
+}
+function resolvedID(v) {
+    const out = v?.trim();
+    if (out === undefined || out === "" || out === ZeroID) {
+        return undefined;
+    }
+    return out;
+}
+function normalizeIDs(ids) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of ids) {
+        const id = raw.trim();
+        if (id === "" || seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        out.push(id);
+    }
+    return out;
+}
+function unionIDs(a, b) {
+    return normalizeIDs([...a, ...b]);
+}
+function withoutID(ids, removed_id) {
+    return normalizeIDs(ids).filter((id) => id !== removed_id);
+}

package/dist/src/marketplace/marketplace.d.ts

@@ -0,0 +1,35 @@
+import { type RPMarketplacePull } from "@fabriktor/schema";
+import type { MarketplaceOperator, OperationResultOf } from "@fabriktor/client";
+import { type PullSession, type PullSessionErrorHandler } from "../core/pull.js";
+type MarketplacePullOptions = Parameters<MarketplaceOperator["pull"]>[0];
+export type MarketplacePullContext = Pick<MarketplacePullOptions, "pull_type" | "entity_id" | "research" | "research_user_type">;
+export type MarketplacePullResult = OperationResultOf<RPMarketplacePull>;
+export type MarketplaceResearchUserType = MarketplacePullOptions["research_user_type"];
+export type MarketplaceSession = PullSession<MarketplacePullResult>;
+export type MarketplaceSessionErrorHandler = PullSessionErrorHandler;
+export type MarketplaceFXOptions = {
+    marketplace: MarketplaceOperator;
+    keep_alive_interval_ms: number;
+};
+export type StartMarketplaceSessionOptions = MarketplacePullContext & {
+    on_error?: MarketplaceSessionErrorHandler;
+};
+export type StartMarketplaceWelcomeSessionOptions = {
+    country: string;
+    state?: string;
+    research_user_type: MarketplaceResearchUserType;
+    on_error?: MarketplaceSessionErrorHandler;
+};
+export interface MarketplaceFXOperator {
+    startSession(opts: StartMarketplaceSessionOptions): Promise<MarketplaceSession>;
+    startWelcomeSession(opts: StartMarketplaceWelcomeSessionOptions): Promise<MarketplaceSession>;
+}
+export declare class MarketplaceFX implements MarketplaceFXOperator {
+    private marketplace;
+    private keep_alive_interval_ms;
+    constructor(opts: MarketplaceFXOptions);
+    startSession(opts: StartMarketplaceSessionOptions): Promise<MarketplaceSession>;
+    startWelcomeSession(opts: StartMarketplaceWelcomeSessionOptions): Promise<MarketplaceSession>;
+}
+export declare function newMarketplaceFX(opts: MarketplaceFXOptions): MarketplaceFX;
+export {};

package/dist/src/marketplace/marketplace.js

@@ -0,0 +1,159 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+import { PullTypeBatch, PullTypeKeepAlive, PullTypeResearch, } from "@fabriktor/schema";
+import { errRequired, errResolveFailed, errValidation } from "../core/err.js";
+import { newPullSession, } from "../core/pull.js";
+const newMarketplaceSessionToken = "";
+const resourceMarketplaceSessionToken = "marketplace_session_token";
+const msgKeepAliveIntervalInvalid = "Keep-alive interval must be a finite number greater than zero.";
+const msgMarketplaceSessionClosed = "Marketplace session is closed.";
+const msgMarketplacePullInProgress = "A marketplace pull is already in progress.";
+const msgMarketplaceSessionTokenMissing = "Marketplace pull response did not contain a session token.";
+const msgMarketplaceSessionPullTypeInvalid = "Marketplace sessions only support batch and research pull types.";
+const msgMarketplaceEntityIDRequired = "Entity ID is required for a batch marketplace session.";
+const msgMarketplaceResearchRequired = "Research is required for a research marketplace session.";
+const msgMarketplaceCountryRequired = "Country is required for marketplace welcome research.";
+export class MarketplaceFX {
+    marketplace;
+    keep_alive_interval_ms;
+    constructor(opts) {
+        validateMarketplaceFXOptions(opts);
+        this.marketplace = opts.marketplace;
+        this.keep_alive_interval_ms = opts.keep_alive_interval_ms;
+    }
+    async startSession(opts) {
+        const { on_error, ...input } = opts;
+        const context = marketplaceSessionContext(input);
+        const initial = await this.marketplace.pull({
+            ...context,
+            session_token: newMarketplaceSessionToken,
+            is_new_session: true,
+        });
+        const session_token = marketplaceSessionToken(initial);
+        return newPullSession({
+            initial,
+            session_token,
+            keep_alive_interval_ms: this.keep_alive_interval_ms,
+            pull_next: async (token) => {
+                return await this.marketplace.pull({
+                    ...context,
+                    session_token: token,
+                    is_new_session: false,
+                });
+            },
+            keep_alive: async (token) => {
+                return await this.marketplace.pull({
+                    session_token: token,
+                    is_new_session: false,
+                    pull_type: PullTypeKeepAlive,
+                    entity_id: "",
+                    research: "",
+                    research_user_type: "",
+                });
+            },
+            resolve_session_token: marketplaceSessionToken,
+            closed_error: () => errValidation({
+                msg: msgMarketplaceSessionClosed,
+            }),
+            pull_in_progress_error: () => errValidation({
+                msg: msgMarketplacePullInProgress,
+            }),
+            on_error,
+        });
+    }
+    async startWelcomeSession(opts) {
+        const research = marketplaceLocationResearch(opts);
+        return await this.startSession({
+            pull_type: PullTypeResearch,
+            entity_id: "",
+            research,
+            research_user_type: opts.research_user_type,
+            on_error: opts.on_error,
+        });
+    }
+}
+export function newMarketplaceFX(opts) {
+    return new MarketplaceFX(opts);
+}
+function validateMarketplaceFXOptions(opts) {
+    if (!Number.isFinite(opts.keep_alive_interval_ms) ||
+        opts.keep_alive_interval_ms <= 0) {
+        throw errValidation({
+            field: "keep_alive_interval_ms",
+            msg: msgKeepAliveIntervalInvalid,
+        });
+    }
+}
+function marketplaceSessionContext(opts) {
+    switch (opts.pull_type) {
+        case PullTypeBatch: {
+            const entity_id = opts.entity_id.trim();
+            if (entity_id === "") {
+                throw errRequired({
+                    field: "entity_id",
+                    msg: msgMarketplaceEntityIDRequired,
+                });
+            }
+            return {
+                pull_type: PullTypeBatch,
+                entity_id,
+                research: "",
+                research_user_type: "",
+            };
+        }
+        case PullTypeResearch: {
+            const research = opts.research.trim();
+            if (research === "") {
+                throw errRequired({
+                    field: "research",
+                    msg: msgMarketplaceResearchRequired,
+                });
+            }
+            return {
+                pull_type: PullTypeResearch,
+                entity_id: "",
+                research,
+                research_user_type: opts.research_user_type,
+            };
+        }
+        default:
+            throw errValidation({
+                field: "pull_type",
+                msg: msgMarketplaceSessionPullTypeInvalid,
+            });
+    }
+}
+function marketplaceLocationResearch(opts) {
+    const country = opts.country.trim();
+    if (country === "") {
+        throw errRequired({
+            field: "country",
+            msg: msgMarketplaceCountryRequired,
+        });
+    }
+    const state = opts.state?.trim();
+    if (state === undefined || state === "") {
+        return country;
+    }
+    return `${state}, ${country}`;
+}
+function marketplaceSessionToken(out) {
+    const token = resolvedValue(out.value?.session_token);
+    if (token === undefined) {
+        throw errResolveFailed({
+            resource: resourceMarketplaceSessionToken,
+            msg: msgMarketplaceSessionTokenMissing,
+        });
+    }
+    return token;
+}
+function resolvedValue(v) {
+    const out = v?.trim();
+    if (out === undefined || out.length === 0) {
+        return undefined;
+    }
+    return out;
+}

package/dist/src/notifications/notifications.d.ts

@@ -0,0 +1,20 @@
+import type { NotificationsOperator } from "@fabriktor/client";
+export type DeviceTokenProvider = () => Promise<string>;
+export type NotificationsFXOptions = {
+    notifications: NotificationsOperator;
+    get_device_token: DeviceTokenProvider;
+};
+export type SyncDeviceTokenOptions = {
+    owner_id: string;
+};
+export type SyncDeviceTokenResult = Awaited<ReturnType<NotificationsOperator["upsertOneDTok"]>>;
+export interface NotificationsFXOperator {
+    syncDeviceToken(opts: SyncDeviceTokenOptions): Promise<SyncDeviceTokenResult>;
+}
+export declare class NotificationsFX implements NotificationsFXOperator {
+    private notifications;
+    private getDeviceToken;
+    constructor(opts: NotificationsFXOptions);
+    syncDeviceToken(opts: SyncDeviceTokenOptions): Promise<SyncDeviceTokenResult>;
+}
+export declare function newNotificationsFX(opts: NotificationsFXOptions): NotificationsFX;

package/dist/src/notifications/notifications.js

@@ -0,0 +1,45 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+import { ZeroID } from "@fabriktor/schema";
+import { errRequired } from "../core/err.js";
+const msgOwnerIDRequired = "Owner ID is required.";
+const msgDeviceTokenRequired = "Device token is required.";
+export class NotificationsFX {
+    notifications;
+    getDeviceToken;
+    constructor(opts) {
+        this.notifications = opts.notifications;
+        this.getDeviceToken = opts.get_device_token;
+    }
+    async syncDeviceToken(opts) {
+        const owner_id = opts.owner_id.trim();
+        if (owner_id === "" || owner_id === ZeroID) {
+            throw errRequired({
+                field: "owner_id",
+                msg: msgOwnerIDRequired,
+            });
+        }
+        const token = (await this.getDeviceToken()).trim();
+        if (token === "") {
+            throw errRequired({
+                field: "token",
+                msg: msgDeviceTokenRequired,
+            });
+        }
+        const input = {
+            in: {
+                token,
+            },
+            query: {
+                owner_id,
+            },
+        };
+        return await this.notifications.upsertOneDTok(input);
+    }
+}
+export function newNotificationsFX(opts) {
+    return new NotificationsFX(opts);
+}

package/dist/src/payments/payments.d.ts

@@ -0,0 +1,59 @@
+import { type Payment, type PmtPublicSession } from "@fabriktor/schema";
+import type { PaymentsOperator } from "@fabriktor/client";
+type PurchaseCreditsPayload = Parameters<PaymentsOperator["purchaseCredits"]>[0];
+type OpenPublicSessionPayload = Parameters<PaymentsOperator["openPmtPublicSession"]>[0];
+type PaymentFromPublicSessionPayload = Parameters<PaymentsOperator["paymentFromPublicSession"]>[0];
+export declare const PublicPaymentSessionStatus: {
+    readonly NotFound: "not_found";
+    readonly Ready: "ready";
+    readonly InternalClient: "internal_client";
+    readonly Consumed: "consumed";
+};
+export type PublicPaymentSessionStatus = (typeof PublicPaymentSessionStatus)[keyof typeof PublicPaymentSessionStatus];
+export type PurchaseAppleCreditsOptions = Pick<PurchaseCreditsPayload, "pkg" | "iap_apple">;
+export type PurchaseGoogleCreditsOptions = Pick<PurchaseCreditsPayload, "pkg" | "iap_google">;
+export type PrepareStripeCreditPurchaseOptions = Pick<PurchaseCreditsPayload, "pkg" | "payer_payment_method_psp_id" | "return_url">;
+export type ConfirmStripeCreditPurchaseOptions = {
+    payment: Payment;
+};
+export type OpenDirectPublicPaymentSessionOptions = Pick<OpenPublicSessionPayload, "entity_id" | "type">;
+export type OpenLookupPublicPaymentSessionOptions = Pick<OpenPublicSessionPayload, "username" | "type" | "entity_number" | "amount">;
+export type PayPublicSessionOptions = Omit<PaymentFromPublicSessionPayload, "pmt_public_session_id"> & {
+    session: PmtPublicSession;
+};
+export type PrepareStripeCreditPurchaseResult = Payment;
+export type ConfirmStripeCreditPurchaseResult = Awaited<ReturnType<PaymentsOperator["replaceOnePayment"]>>;
+export type PayPublicSessionResult = Awaited<ReturnType<PaymentsOperator["paymentFromPublicSession"]>>;
+export type OpenPublicPaymentSessionResult = {
+    status: typeof PublicPaymentSessionStatus.NotFound;
+} | {
+    status: typeof PublicPaymentSessionStatus.Ready | typeof PublicPaymentSessionStatus.InternalClient | typeof PublicPaymentSessionStatus.Consumed;
+    session: PmtPublicSession;
+};
+export type PaymentsFXOptions = {
+    payments: PaymentsOperator;
+};
+export interface PaymentsFXOperator {
+    purchaseAppleCredits(opts: PurchaseAppleCreditsOptions): Promise<void>;
+    purchaseGoogleCredits(opts: PurchaseGoogleCreditsOptions): Promise<void>;
+    prepareStripeCreditPurchase(opts: PrepareStripeCreditPurchaseOptions): Promise<PrepareStripeCreditPurchaseResult>;
+    confirmStripeCreditPurchase(opts: ConfirmStripeCreditPurchaseOptions): Promise<ConfirmStripeCreditPurchaseResult>;
+    openDirectPublicPaymentSession(opts: OpenDirectPublicPaymentSessionOptions): Promise<OpenPublicPaymentSessionResult>;
+    openLookupPublicPaymentSession(opts: OpenLookupPublicPaymentSessionOptions): Promise<OpenPublicPaymentSessionResult>;
+    payPublicSession(opts: PayPublicSessionOptions): Promise<PayPublicSessionResult>;
+}
+export declare class PaymentsFX implements PaymentsFXOperator {
+    private payments;
+    private submittedPublicSessionIDs;
+    constructor(opts: PaymentsFXOptions);
+    purchaseAppleCredits(opts: PurchaseAppleCreditsOptions): Promise<void>;
+    purchaseGoogleCredits(opts: PurchaseGoogleCreditsOptions): Promise<void>;
+    prepareStripeCreditPurchase(opts: PrepareStripeCreditPurchaseOptions): Promise<PrepareStripeCreditPurchaseResult>;
+    confirmStripeCreditPurchase(opts: ConfirmStripeCreditPurchaseOptions): Promise<ConfirmStripeCreditPurchaseResult>;
+    openDirectPublicPaymentSession(opts: OpenDirectPublicPaymentSessionOptions): Promise<OpenPublicPaymentSessionResult>;
+    openLookupPublicPaymentSession(opts: OpenLookupPublicPaymentSessionOptions): Promise<OpenPublicPaymentSessionResult>;
+    payPublicSession(opts: PayPublicSessionOptions): Promise<PayPublicSessionResult>;
+    private openPublicPaymentSession;
+}
+export declare function newPaymentsFX(opts: PaymentsFXOptions): PaymentsFX;
+export {};