@fabriktor/fx 0.0.38 → 0.0.40

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

@@ -1,7 +1,23 @@
-import { type RPMarketplacePull } from "@fabriktor/schema";
 import type { MarketplaceOperator, OperationResultOf } from "@fabriktor/client";
+import { type MarketplaceFavorite, type MarketplacePost, type RPMarketplacePull } from "@fabriktor/schema";
 import { type PullSession, type PullSessionErrorHandler } from "../core/pull.js";
+import { type SearchPage } from "../core/search.js";
+type MarketplacePostInsertOptions = Parameters<MarketplaceOperator["insertOneMarketplacePost"]>[0];
+type MarketplacePostReplaceOptions = Parameters<MarketplaceOperator["replaceOneMarketplacePost"]>[0];
+type MarketplaceFavoriteInsertOptions = Parameters<MarketplaceOperator["insertOneMarketplaceFavorite"]>[0];
+type MarketplaceFavoriteReplaceOptions = Parameters<MarketplaceOperator["replaceOneMarketplaceFavorite"]>[0];
 type MarketplacePullOptions = Parameters<MarketplaceOperator["pull"]>[0];
+export type CreateMarketplacePostOptions = MarketplacePostInsertOptions;
+export type ReplaceMarketplacePostOptions = MarketplacePostReplaceOptions;
+export type CreateMarketplaceFavoriteOptions = MarketplaceFavoriteInsertOptions;
+export type ReplaceMarketplaceFavoriteOptions = MarketplaceFavoriteReplaceOptions;
+export type SearchMarketplacePostsOptions = {
+    owner_id: string;
+    q?: string;
+    page?: number;
+    per_page?: number;
+};
+export type SearchMarketplacePostsPage = SearchPage<MarketplacePost>;
 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"];
@@ -21,6 +37,11 @@ export type StartMarketplaceWelcomeSessionOptions = {
     on_error?: MarketplaceSessionErrorHandler;
 };
 export interface MarketplaceFXOperator {
+    createMarketplacePost(opts: CreateMarketplacePostOptions): Promise<MarketplacePost>;
+    replaceMarketplacePost(opts: ReplaceMarketplacePostOptions): Promise<MarketplacePost>;
+    searchMarketplacePosts(opts: SearchMarketplacePostsOptions): Promise<SearchMarketplacePostsPage>;
+    createMarketplaceFavorite(opts: CreateMarketplaceFavoriteOptions): Promise<MarketplaceFavorite>;
+    replaceMarketplaceFavorite(opts: ReplaceMarketplaceFavoriteOptions): Promise<MarketplaceFavorite>;
     startSession(opts: StartMarketplaceSessionOptions): Promise<MarketplaceSession>;
     startWelcomeSession(opts: StartMarketplaceWelcomeSessionOptions): Promise<MarketplaceSession>;
 }
@@ -28,8 +49,15 @@ export declare class MarketplaceFX implements MarketplaceFXOperator {
     private marketplace;
     private keep_alive_interval_ms;
     constructor(opts: MarketplaceFXOptions);
+    createMarketplacePost(opts: CreateMarketplacePostOptions): Promise<MarketplacePost>;
+    replaceMarketplacePost(opts: ReplaceMarketplacePostOptions): Promise<MarketplacePost>;
+    searchMarketplacePosts(opts: SearchMarketplacePostsOptions): Promise<SearchMarketplacePostsPage>;
+    createMarketplaceFavorite(opts: CreateMarketplaceFavoriteOptions): Promise<MarketplaceFavorite>;
+    replaceMarketplaceFavorite(opts: ReplaceMarketplaceFavoriteOptions): Promise<MarketplaceFavorite>;
     startSession(opts: StartMarketplaceSessionOptions): Promise<MarketplaceSession>;
     startWelcomeSession(opts: StartMarketplaceWelcomeSessionOptions): Promise<MarketplaceSession>;
+    private findMarketplacePost;
+    private findMarketplaceFavorite;
 }
 export declare function newMarketplaceFX(opts: MarketplaceFXOptions): MarketplaceFX;
 export {};

package/dist/src/marketplace/marketplace.js

@@ -3,11 +3,19 @@
 // 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 { OwnerIDKey, PullTypeBatch, PullTypeKeepAlive, PullTypeResearch, } from "@fabriktor/schema";
 import { errRequired, errResolveFailed, errValidation } from "../core/err.js";
+import { requiredOperationID } from "../core/id.js";
 import { newPullSession, } from "../core/pull.js";
+import { runSearch } from "../core/search.js";
 const newMarketplaceSessionToken = "";
 const resourceMarketplaceSessionToken = "marketplace_session_token";
+const resourceMarketplacePost = "marketplace_post";
+const resourceMarketplaceFavorite = "marketplace_favorite";
+const msgCreatedMarketplacePostIDMissing = "Created marketplace post response did not contain an ID.";
+const msgMarketplacePostMissing = "Marketplace post could not be resolved after the mutation.";
+const msgCreatedMarketplaceFavoriteIDMissing = "Created marketplace favorite response did not contain an ID.";
+const msgMarketplaceFavoriteMissing = "Marketplace favorite could not be resolved after the mutation.";
 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.";
@@ -24,6 +32,35 @@ export class MarketplaceFX {
         this.marketplace = opts.marketplace;
         this.keep_alive_interval_ms = opts.keep_alive_interval_ms;
     }
+    async createMarketplacePost(opts) {
+        const out = await this.marketplace.insertOneMarketplacePost(opts);
+        const id = requiredOperationID(out, msgCreatedMarketplacePostIDMissing);
+        return await this.findMarketplacePost(id);
+    }
+    async replaceMarketplacePost(opts) {
+        await this.marketplace.replaceOneMarketplacePost(opts);
+        return await this.findMarketplacePost(opts.id);
+    }
+    async searchMarketplacePosts(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.marketplace.searchManyMarketplacePosts(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createMarketplaceFavorite(opts) {
+        const out = await this.marketplace.insertOneMarketplaceFavorite(opts);
+        const id = requiredOperationID(out, msgCreatedMarketplaceFavoriteIDMissing);
+        return await this.findMarketplaceFavorite(id);
+    }
+    async replaceMarketplaceFavorite(opts) {
+        await this.marketplace.replaceOneMarketplaceFavorite(opts);
+        return await this.findMarketplaceFavorite(opts.id);
+    }
     async startSession(opts) {
         const { on_error, ...input } = opts;
         const context = marketplaceSessionContext(input);
@@ -74,6 +111,32 @@ export class MarketplaceFX {
             on_error: opts.on_error,
         });
     }
+    async findMarketplacePost(id) {
+        const out = await this.marketplace.findOneMarketplacePost({
+            id,
+        });
+        const post = out.value;
+        if (post === undefined) {
+            throw errResolveFailed({
+                resource: resourceMarketplacePost,
+                msg: msgMarketplacePostMissing,
+            });
+        }
+        return post;
+    }
+    async findMarketplaceFavorite(id) {
+        const out = await this.marketplace.findOneMarketplaceFavorite({
+            id,
+        });
+        const favorite = out.value;
+        if (favorite === undefined) {
+            throw errResolveFailed({
+                resource: resourceMarketplaceFavorite,
+                msg: msgMarketplaceFavoriteMissing,
+            });
+        }
+        return favorite;
+    }
 }
 export function newMarketplaceFX(opts) {
     return new MarketplaceFX(opts);

package/dist/src/memos/memos.js

@@ -3,12 +3,11 @@
 // 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 { OwnerIDKey, ZeroID, } from "@fabriktor/schema";
+import { OwnerIDKey } from "@fabriktor/schema";
 import { errResolveFailed } from "../core/err.js";
+import { requiredOperationID } from "../core/id.js";
 import { runSearch } from "../core/search.js";
-const resourceMemoID = "memo_id";
 const resourceMemo = "memo";
-const resourceMemoFolderID = "memo_folder_id";
 const resourceMemoFolder = "memo_folder";
 const msgCreatedMemoIDMissing = "Created memo response did not contain an ID.";
 const msgMemoMissing = "Memo could not be resolved after the mutation.";
@@ -21,10 +20,7 @@ export class MemosFX {
     }
     async createMemo(opts) {
         const out = await this.memos.insertOneMemo(opts);
-        const id = requiredOperationID(out, {
-            resource: resourceMemoID,
-            msg: msgCreatedMemoIDMissing,
-        });
+        const id = requiredOperationID(out, msgCreatedMemoIDMissing);
         return await this.findMemo(id);
     }
     async replaceMemo(opts) {
@@ -33,10 +29,7 @@ export class MemosFX {
     }
     async createMemoFolder(opts) {
         const out = await this.memos.insertOneMemoFolder(opts);
-        const id = requiredOperationID(out, {
-            resource: resourceMemoFolderID,
-            msg: msgCreatedMemoFolderIDMissing,
-        });
+        const id = requiredOperationID(out, msgCreatedMemoFolderIDMissing);
         return await this.findMemoFolder(id);
     }
     async replaceMemoFolder(opts) {
@@ -95,20 +88,3 @@ export class MemosFX {
 export function newMemosFX(opts) {
     return new MemosFX(opts);
 }
-function requiredOperationID(out, opts) {
-    const id = resolvedID(out.id);
-    if (id === undefined) {
-        throw errResolveFailed({
-            resource: opts.resource,
-            msg: opts.msg,
-        });
-    }
-    return id;
-}
-function resolvedID(value) {
-    const id = value?.trim();
-    if (id === undefined || id === "" || id === ZeroID) {
-        return undefined;
-    }
-    return id;
-}

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

@@ -1,8 +1,63 @@
-import { type Payment, type PmtPublicSession } from "@fabriktor/schema";
+import { type CreditLedgerEntry, type Payment, type PmtAccount, type PmtBankAccount, type PmtCard, type PmtCustomer, type PmtPublicSession, type PmtRefund } from "@fabriktor/schema";
 import type { PaymentsOperator } from "@fabriktor/client";
+import { type SearchPage } from "../core/search.js";
 type PurchaseCreditsPayload = Parameters<PaymentsOperator["purchaseCredits"]>[0];
 type OpenPublicSessionPayload = Parameters<PaymentsOperator["openPmtPublicSession"]>[0];
 type PaymentFromPublicSessionPayload = Parameters<PaymentsOperator["paymentFromPublicSession"]>[0];
+type PaymentInsertOptions = Parameters<PaymentsOperator["insertOnePayment"]>[0];
+type PaymentReplaceOptions = Parameters<PaymentsOperator["replaceOnePayment"]>[0];
+type PmtAccountInsertOptions = Parameters<PaymentsOperator["insertOnePmtAccount"]>[0];
+type PmtAccountReplaceOptions = Parameters<PaymentsOperator["replaceOnePmtAccount"]>[0];
+type PmtBankAccountInsertOptions = Parameters<PaymentsOperator["insertOnePmtBankAccount"]>[0];
+type PmtBankAccountReplaceOptions = Parameters<PaymentsOperator["replaceOnePmtBankAccount"]>[0];
+type PmtCardInsertOptions = Parameters<PaymentsOperator["insertOnePmtCard"]>[0];
+type PmtCardReplaceOptions = Parameters<PaymentsOperator["replaceOnePmtCard"]>[0];
+type PmtRefundInsertOptions = Parameters<PaymentsOperator["insertOnePmtRefund"]>[0];
+type PmtRefundReplaceOptions = Parameters<PaymentsOperator["replaceOnePmtRefund"]>[0];
+type PmtCustomerInsertOptions = Parameters<PaymentsOperator["insertOnePmtCustomer"]>[0];
+type PmtCustomerReplaceOptions = Parameters<PaymentsOperator["replaceOnePmtCustomer"]>[0];
+type PmtPublicSessionInsertOptions = Parameters<PaymentsOperator["insertOnePmtPublicSession"]>[0];
+type PmtPublicSessionReplaceOptions = Parameters<PaymentsOperator["replaceOnePmtPublicSession"]>[0];
+type CreditLedgerEntryInsertOptions = Parameters<PaymentsOperator["insertOneCreditLedgerEntry"]>[0];
+type CreditLedgerEntryReplaceOptions = Parameters<PaymentsOperator["replaceOneCreditLedgerEntry"]>[0];
+type SearchPaymentRecordsOptions = {
+    owner_id: string;
+    q?: string;
+    page?: number;
+    per_page?: number;
+};
+export type CreatePaymentOptions = PaymentInsertOptions;
+export type ReplacePaymentOptions = PaymentReplaceOptions;
+export type SearchPaymentsOptions = SearchPaymentRecordsOptions;
+export type SearchPaymentsPage = SearchPage<Payment>;
+export type CreatePmtAccountOptions = PmtAccountInsertOptions;
+export type ReplacePmtAccountOptions = PmtAccountReplaceOptions;
+export type SearchPmtAccountsOptions = SearchPaymentRecordsOptions;
+export type SearchPmtAccountsPage = SearchPage<PmtAccount>;
+export type CreatePmtBankAccountOptions = PmtBankAccountInsertOptions;
+export type ReplacePmtBankAccountOptions = PmtBankAccountReplaceOptions;
+export type SearchPmtBankAccountsOptions = SearchPaymentRecordsOptions;
+export type SearchPmtBankAccountsPage = SearchPage<PmtBankAccount>;
+export type CreatePmtCardOptions = PmtCardInsertOptions;
+export type ReplacePmtCardOptions = PmtCardReplaceOptions;
+export type SearchPmtCardsOptions = SearchPaymentRecordsOptions;
+export type SearchPmtCardsPage = SearchPage<PmtCard>;
+export type CreatePmtRefundOptions = PmtRefundInsertOptions;
+export type ReplacePmtRefundOptions = PmtRefundReplaceOptions;
+export type SearchPmtRefundsOptions = SearchPaymentRecordsOptions;
+export type SearchPmtRefundsPage = SearchPage<PmtRefund>;
+export type CreatePmtCustomerOptions = PmtCustomerInsertOptions;
+export type ReplacePmtCustomerOptions = PmtCustomerReplaceOptions;
+export type SearchPmtCustomersOptions = SearchPaymentRecordsOptions;
+export type SearchPmtCustomersPage = SearchPage<PmtCustomer>;
+export type CreatePmtPublicSessionOptions = PmtPublicSessionInsertOptions;
+export type ReplacePmtPublicSessionOptions = PmtPublicSessionReplaceOptions;
+export type SearchPmtPublicSessionsOptions = SearchPaymentRecordsOptions;
+export type SearchPmtPublicSessionsPage = SearchPage<PmtPublicSession>;
+export type CreateCreditLedgerEntryOptions = CreditLedgerEntryInsertOptions;
+export type ReplaceCreditLedgerEntryOptions = CreditLedgerEntryReplaceOptions;
+export type SearchCreditLedgerOptions = SearchPaymentRecordsOptions;
+export type SearchCreditLedgerPage = SearchPage<CreditLedgerEntry>;
 export declare const PublicPaymentSessionStatus: {
     readonly NotFound: "not_found";
     readonly Ready: "ready";
@@ -34,6 +89,30 @@ export type PaymentsFXOptions = {
     payments: PaymentsOperator;
 };
 export interface PaymentsFXOperator {
+    createPayment(opts: CreatePaymentOptions): Promise<Payment>;
+    replacePayment(opts: ReplacePaymentOptions): Promise<Payment>;
+    searchPayments(opts: SearchPaymentsOptions): Promise<SearchPaymentsPage>;
+    createPmtAccount(opts: CreatePmtAccountOptions): Promise<PmtAccount>;
+    replacePmtAccount(opts: ReplacePmtAccountOptions): Promise<PmtAccount>;
+    searchPmtAccounts(opts: SearchPmtAccountsOptions): Promise<SearchPmtAccountsPage>;
+    createPmtBankAccount(opts: CreatePmtBankAccountOptions): Promise<PmtBankAccount>;
+    replacePmtBankAccount(opts: ReplacePmtBankAccountOptions): Promise<PmtBankAccount>;
+    searchPmtBankAccounts(opts: SearchPmtBankAccountsOptions): Promise<SearchPmtBankAccountsPage>;
+    createPmtCard(opts: CreatePmtCardOptions): Promise<PmtCard>;
+    replacePmtCard(opts: ReplacePmtCardOptions): Promise<PmtCard>;
+    searchPmtCards(opts: SearchPmtCardsOptions): Promise<SearchPmtCardsPage>;
+    createPmtRefund(opts: CreatePmtRefundOptions): Promise<PmtRefund>;
+    replacePmtRefund(opts: ReplacePmtRefundOptions): Promise<PmtRefund>;
+    searchPmtRefunds(opts: SearchPmtRefundsOptions): Promise<SearchPmtRefundsPage>;
+    createPmtCustomer(opts: CreatePmtCustomerOptions): Promise<PmtCustomer>;
+    replacePmtCustomer(opts: ReplacePmtCustomerOptions): Promise<PmtCustomer>;
+    searchPmtCustomers(opts: SearchPmtCustomersOptions): Promise<SearchPmtCustomersPage>;
+    createPmtPublicSession(opts: CreatePmtPublicSessionOptions): Promise<PmtPublicSession>;
+    replacePmtPublicSession(opts: ReplacePmtPublicSessionOptions): Promise<PmtPublicSession>;
+    searchPmtPublicSessions(opts: SearchPmtPublicSessionsOptions): Promise<SearchPmtPublicSessionsPage>;
+    createCreditLedgerEntry(opts: CreateCreditLedgerEntryOptions): Promise<CreditLedgerEntry>;
+    replaceCreditLedgerEntry(opts: ReplaceCreditLedgerEntryOptions): Promise<CreditLedgerEntry>;
+    searchCreditLedger(opts: SearchCreditLedgerOptions): Promise<SearchCreditLedgerPage>;
     purchaseAppleCredits(opts: PurchaseAppleCreditsOptions): Promise<void>;
     purchaseGoogleCredits(opts: PurchaseGoogleCreditsOptions): Promise<void>;
     prepareStripeCreditPurchase(opts: PrepareStripeCreditPurchaseOptions): Promise<PrepareStripeCreditPurchaseResult>;
@@ -46,6 +125,30 @@ export declare class PaymentsFX implements PaymentsFXOperator {
     private payments;
     private submittedPublicSessionIDs;
     constructor(opts: PaymentsFXOptions);
+    createPayment(opts: CreatePaymentOptions): Promise<Payment>;
+    replacePayment(opts: ReplacePaymentOptions): Promise<Payment>;
+    searchPayments(opts: SearchPaymentsOptions): Promise<SearchPaymentsPage>;
+    createPmtAccount(opts: CreatePmtAccountOptions): Promise<PmtAccount>;
+    replacePmtAccount(opts: ReplacePmtAccountOptions): Promise<PmtAccount>;
+    searchPmtAccounts(opts: SearchPmtAccountsOptions): Promise<SearchPmtAccountsPage>;
+    createPmtBankAccount(opts: CreatePmtBankAccountOptions): Promise<PmtBankAccount>;
+    replacePmtBankAccount(opts: ReplacePmtBankAccountOptions): Promise<PmtBankAccount>;
+    searchPmtBankAccounts(opts: SearchPmtBankAccountsOptions): Promise<SearchPmtBankAccountsPage>;
+    createPmtCard(opts: CreatePmtCardOptions): Promise<PmtCard>;
+    replacePmtCard(opts: ReplacePmtCardOptions): Promise<PmtCard>;
+    searchPmtCards(opts: SearchPmtCardsOptions): Promise<SearchPmtCardsPage>;
+    createPmtRefund(opts: CreatePmtRefundOptions): Promise<PmtRefund>;
+    replacePmtRefund(opts: ReplacePmtRefundOptions): Promise<PmtRefund>;
+    searchPmtRefunds(opts: SearchPmtRefundsOptions): Promise<SearchPmtRefundsPage>;
+    createPmtCustomer(opts: CreatePmtCustomerOptions): Promise<PmtCustomer>;
+    replacePmtCustomer(opts: ReplacePmtCustomerOptions): Promise<PmtCustomer>;
+    searchPmtCustomers(opts: SearchPmtCustomersOptions): Promise<SearchPmtCustomersPage>;
+    createPmtPublicSession(opts: CreatePmtPublicSessionOptions): Promise<PmtPublicSession>;
+    replacePmtPublicSession(opts: ReplacePmtPublicSessionOptions): Promise<PmtPublicSession>;
+    searchPmtPublicSessions(opts: SearchPmtPublicSessionsOptions): Promise<SearchPmtPublicSessionsPage>;
+    createCreditLedgerEntry(opts: CreateCreditLedgerEntryOptions): Promise<CreditLedgerEntry>;
+    replaceCreditLedgerEntry(opts: ReplaceCreditLedgerEntryOptions): Promise<CreditLedgerEntry>;
+    searchCreditLedger(opts: SearchCreditLedgerOptions): Promise<SearchCreditLedgerPage>;
     purchaseAppleCredits(opts: PurchaseAppleCreditsOptions): Promise<void>;
     purchaseGoogleCredits(opts: PurchaseGoogleCreditsOptions): Promise<void>;
     prepareStripeCreditPurchase(opts: PrepareStripeCreditPurchaseOptions): Promise<PrepareStripeCreditPurchaseResult>;
@@ -53,6 +156,14 @@ export declare class PaymentsFX implements PaymentsFXOperator {
     openDirectPublicPaymentSession(opts: OpenDirectPublicPaymentSessionOptions): Promise<OpenPublicPaymentSessionResult>;
     openLookupPublicPaymentSession(opts: OpenLookupPublicPaymentSessionOptions): Promise<OpenPublicPaymentSessionResult>;
     payPublicSession(opts: PayPublicSessionOptions): Promise<PayPublicSessionResult>;
+    private findPayment;
+    private findPmtAccount;
+    private findPmtBankAccount;
+    private findPmtCard;
+    private findPmtRefund;
+    private findPmtCustomer;
+    private findPmtPublicSession;
+    private findCreditLedgerEntry;
     private openPublicPaymentSession;
 }
 export declare function newPaymentsFX(opts: PaymentsFXOptions): PaymentsFX;

package/dist/src/payments/payments.js

@@ -3,11 +3,37 @@
 // 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 { CreditLedgerSourceAndroidIAP, CreditLedgerSourceAppleIAP, CreditLedgerSourceStripe, ZeroID, } from "@fabriktor/schema";
+import { CreditLedgerSourceAndroidIAP, CreditLedgerSourceAppleIAP, CreditLedgerSourceStripe, OwnerIDKey, ZeroID, } from "@fabriktor/schema";
 import { errResolveFailed, errValidation } from "../core/err.js";
+import { requiredOperationID, resolvedID } from "../core/id.js";
+import { runSearch } from "../core/search.js";
 const publicAmountPattern = /^\d+$/;
+const resourcePayment = "payment";
+const resourcePmtAccount = "pmt_account";
+const resourcePmtBankAccount = "pmt_bank_account";
+const resourcePmtCard = "pmt_card";
+const resourcePmtRefund = "pmt_refund";
+const resourcePmtCustomer = "pmt_customer";
+const resourcePmtPublicSession = "pmt_public_session";
+const resourceCreditLedgerEntry = "credit_ledger_entry";
 const resourceStripeCreditPayment = "stripe credit payment";
 const resourcePublicPaymentSession = "public payment session";
+const msgCreatedPaymentIDMissing = "Created payment response did not contain an ID.";
+const msgPaymentMissing = "Payment could not be resolved after the mutation.";
+const msgCreatedPmtAccountIDMissing = "Created payment account response did not contain an ID.";
+const msgPmtAccountMissing = "Payment account could not be resolved after the mutation.";
+const msgCreatedPmtBankAccountIDMissing = "Created payment bank account response did not contain an ID.";
+const msgPmtBankAccountMissing = "Payment bank account could not be resolved after the mutation.";
+const msgCreatedPmtCardIDMissing = "Created payment card response did not contain an ID.";
+const msgPmtCardMissing = "Payment card could not be resolved after the mutation.";
+const msgCreatedPmtRefundIDMissing = "Created payment refund response did not contain an ID.";
+const msgPmtRefundMissing = "Payment refund could not be resolved after the mutation.";
+const msgCreatedPmtCustomerIDMissing = "Created payment customer response did not contain an ID.";
+const msgPmtCustomerMissing = "Payment customer could not be resolved after the mutation.";
+const msgCreatedPmtPublicSessionIDMissing = "Created payment public session response did not contain an ID.";
+const msgPmtPublicSessionMissing = "Payment public session could not be resolved after the mutation.";
+const msgCreatedCreditLedgerEntryIDMissing = "Created credit ledger entry response did not contain an ID.";
+const msgCreditLedgerEntryMissing = "Credit ledger entry could not be resolved after the mutation.";
 const msgStripeCreditPaymentIDMissing = "Stripe credit payment ID could not be resolved.";
 const msgStripeCreditPaymentMissing = "Stripe credit payment could not be resolved.";
 const msgStripeCreditPaymentAlreadyConfirmed = "Stripe credit payment is already confirmed.";
@@ -30,6 +56,166 @@ export class PaymentsFX {
         this.payments = opts.payments;
         this.submittedPublicSessionIDs = new Set();
     }
+    async createPayment(opts) {
+        const out = await this.payments.insertOnePayment(opts);
+        const id = requiredOperationID(out, msgCreatedPaymentIDMissing);
+        return await this.findPayment(id);
+    }
+    async replacePayment(opts) {
+        await this.payments.replaceOnePayment(opts);
+        return await this.findPayment(opts.id);
+    }
+    async searchPayments(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payments.searchManyPayments(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createPmtAccount(opts) {
+        const out = await this.payments.insertOnePmtAccount(opts);
+        const id = requiredOperationID(out, msgCreatedPmtAccountIDMissing);
+        return await this.findPmtAccount(id);
+    }
+    async replacePmtAccount(opts) {
+        await this.payments.replaceOnePmtAccount(opts);
+        return await this.findPmtAccount(opts.id);
+    }
+    async searchPmtAccounts(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payments.searchManyPmtAccounts(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createPmtBankAccount(opts) {
+        const out = await this.payments.insertOnePmtBankAccount(opts);
+        const id = requiredOperationID(out, msgCreatedPmtBankAccountIDMissing);
+        return await this.findPmtBankAccount(id);
+    }
+    async replacePmtBankAccount(opts) {
+        await this.payments.replaceOnePmtBankAccount(opts);
+        return await this.findPmtBankAccount(opts.id);
+    }
+    async searchPmtBankAccounts(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payments.searchManyPmtBankAccounts(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createPmtCard(opts) {
+        const out = await this.payments.insertOnePmtCard(opts);
+        const id = requiredOperationID(out, msgCreatedPmtCardIDMissing);
+        return await this.findPmtCard(id);
+    }
+    async replacePmtCard(opts) {
+        await this.payments.replaceOnePmtCard(opts);
+        return await this.findPmtCard(opts.id);
+    }
+    async searchPmtCards(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payments.searchManyPmtCards(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createPmtRefund(opts) {
+        const out = await this.payments.insertOnePmtRefund(opts);
+        const id = requiredOperationID(out, msgCreatedPmtRefundIDMissing);
+        return await this.findPmtRefund(id);
+    }
+    async replacePmtRefund(opts) {
+        await this.payments.replaceOnePmtRefund(opts);
+        return await this.findPmtRefund(opts.id);
+    }
+    async searchPmtRefunds(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payments.searchManyPmtRefunds(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createPmtCustomer(opts) {
+        const out = await this.payments.insertOnePmtCustomer(opts);
+        const id = requiredOperationID(out, msgCreatedPmtCustomerIDMissing);
+        return await this.findPmtCustomer(id);
+    }
+    async replacePmtCustomer(opts) {
+        await this.payments.replaceOnePmtCustomer(opts);
+        return await this.findPmtCustomer(opts.id);
+    }
+    async searchPmtCustomers(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payments.searchManyPmtCustomers(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createPmtPublicSession(opts) {
+        const out = await this.payments.insertOnePmtPublicSession(opts);
+        const id = requiredOperationID(out, msgCreatedPmtPublicSessionIDMissing);
+        return await this.findPmtPublicSession(id);
+    }
+    async replacePmtPublicSession(opts) {
+        await this.payments.replaceOnePmtPublicSession(opts);
+        return await this.findPmtPublicSession(opts.id);
+    }
+    async searchPmtPublicSessions(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payments.searchManyPmtPublicSessions(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createCreditLedgerEntry(opts) {
+        const out = await this.payments.insertOneCreditLedgerEntry(opts);
+        const id = requiredOperationID(out, msgCreatedCreditLedgerEntryIDMissing);
+        return await this.findCreditLedgerEntry(id);
+    }
+    async replaceCreditLedgerEntry(opts) {
+        await this.payments.replaceOneCreditLedgerEntry(opts);
+        return await this.findCreditLedgerEntry(opts.id);
+    }
+    async searchCreditLedger(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.payments.searchManyCreditLedger(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
     async purchaseAppleCredits(opts) {
         await this.payments.purchaseCredits({
             src: CreditLedgerSourceAppleIAP,
@@ -145,6 +331,110 @@ export class PaymentsFX {
             throw err;
         }
     }
+    async findPayment(id) {
+        const out = await this.payments.findOnePayment({
+            id,
+        });
+        const payment = out.value;
+        if (payment === undefined) {
+            throw errResolveFailed({
+                resource: resourcePayment,
+                msg: msgPaymentMissing,
+            });
+        }
+        return payment;
+    }
+    async findPmtAccount(id) {
+        const out = await this.payments.findOnePmtAccount({
+            id,
+        });
+        const account = out.value;
+        if (account === undefined) {
+            throw errResolveFailed({
+                resource: resourcePmtAccount,
+                msg: msgPmtAccountMissing,
+            });
+        }
+        return account;
+    }
+    async findPmtBankAccount(id) {
+        const out = await this.payments.findOnePmtBankAccount({
+            id,
+        });
+        const account = out.value;
+        if (account === undefined) {
+            throw errResolveFailed({
+                resource: resourcePmtBankAccount,
+                msg: msgPmtBankAccountMissing,
+            });
+        }
+        return account;
+    }
+    async findPmtCard(id) {
+        const out = await this.payments.findOnePmtCard({
+            id,
+        });
+        const card = out.value;
+        if (card === undefined) {
+            throw errResolveFailed({
+                resource: resourcePmtCard,
+                msg: msgPmtCardMissing,
+            });
+        }
+        return card;
+    }
+    async findPmtRefund(id) {
+        const out = await this.payments.findOnePmtRefund({
+            id,
+        });
+        const refund = out.value;
+        if (refund === undefined) {
+            throw errResolveFailed({
+                resource: resourcePmtRefund,
+                msg: msgPmtRefundMissing,
+            });
+        }
+        return refund;
+    }
+    async findPmtCustomer(id) {
+        const out = await this.payments.findOnePmtCustomer({
+            id,
+        });
+        const customer = out.value;
+        if (customer === undefined) {
+            throw errResolveFailed({
+                resource: resourcePmtCustomer,
+                msg: msgPmtCustomerMissing,
+            });
+        }
+        return customer;
+    }
+    async findPmtPublicSession(id) {
+        const out = await this.payments.findOnePmtPublicSession({
+            id,
+        });
+        const session = out.value;
+        if (session === undefined) {
+            throw errResolveFailed({
+                resource: resourcePmtPublicSession,
+                msg: msgPmtPublicSessionMissing,
+            });
+        }
+        return session;
+    }
+    async findCreditLedgerEntry(id) {
+        const out = await this.payments.findOneCreditLedgerEntry({
+            id,
+        });
+        const entry = out.value;
+        if (entry === undefined) {
+            throw errResolveFailed({
+                resource: resourceCreditLedgerEntry,
+                msg: msgCreditLedgerEntryMissing,
+            });
+        }
+        return entry;
+    }
     async openPublicPaymentSession(input) {
         const out = await this.payments.openPmtPublicSession(input);
         if (out === undefined) {
@@ -238,20 +528,6 @@ function publicSessionID(session) {
 function operationID(out) {
     return resolvedID(out.id);
 }
-function resolvedID(v) {
-    const out = resolvedValue(v);
-    if (out === undefined || out === ZeroID) {
-        return undefined;
-    }
-    return out;
-}
-function resolvedValue(v) {
-    const out = v?.trim();
-    if (out === undefined || out.length === 0) {
-        return undefined;
-    }
-    return out;
-}
 function zeroAppleIAP() {
     return {
         transaction_id: "",