@fabriktor/fx 0.0.39 → 0.0.40

package/dist/src/billable/billable.d.ts

@@ -1,6 +1,85 @@
-import type { OperationResult, RPBillablePeriodsFromDates, YearSpan } from "@fabriktor/schema";
 import type { BillableOperator, OperationResultOf } from "@fabriktor/client";
+import { type OperationResult, type RPBillablePeriodsFromDates, type YearSpan, type Bill, type BillableFolder, type Charge, type Equipment, type Item, type LaborRate, type MeterReading, type Quantifier, type Tax, type TmpBillNumber, type VendorInvoice, type Warehouse } from "@fabriktor/schema";
+import { type SearchPage } from "../core/search.js";
 type GenerateBillPayload = Parameters<BillableOperator["generateBill"]>[0];
+type BillInsertOptions = Parameters<BillableOperator["insertOneBill"]>[0];
+type BillReplaceOptions = Parameters<BillableOperator["replaceOneBill"]>[0];
+type BillableFolderInsertOptions = Parameters<BillableOperator["insertOneBillableFolder"]>[0];
+type BillableFolderReplaceOptions = Parameters<BillableOperator["replaceOneBillableFolder"]>[0];
+type ChargeInsertOptions = Parameters<BillableOperator["insertOneCharge"]>[0];
+type ChargeReplaceOptions = Parameters<BillableOperator["replaceOneCharge"]>[0];
+type EquipmentInsertOptions = Parameters<BillableOperator["insertOneEquipment"]>[0];
+type EquipmentReplaceOptions = Parameters<BillableOperator["replaceOneEquipment"]>[0];
+type ItemInsertOptions = Parameters<BillableOperator["insertOneItem"]>[0];
+type ItemReplaceOptions = Parameters<BillableOperator["replaceOneItem"]>[0];
+type LaborRateInsertOptions = Parameters<BillableOperator["insertOneLaborRate"]>[0];
+type LaborRateReplaceOptions = Parameters<BillableOperator["replaceOneLaborRate"]>[0];
+type MeterReadingInsertOptions = Parameters<BillableOperator["insertOneMeterReading"]>[0];
+type MeterReadingReplaceOptions = Parameters<BillableOperator["replaceOneMeterReading"]>[0];
+type QuantifierInsertOptions = Parameters<BillableOperator["insertOneQuantifier"]>[0];
+type QuantifierReplaceOptions = Parameters<BillableOperator["replaceOneQuantifier"]>[0];
+type TaxInsertOptions = Parameters<BillableOperator["insertOneTax"]>[0];
+type TaxReplaceOptions = Parameters<BillableOperator["replaceOneTax"]>[0];
+type TmpBillNumberInsertOptions = Parameters<BillableOperator["insertOneTmpBillNumber"]>[0];
+type TmpBillNumberReplaceOptions = Parameters<BillableOperator["replaceOneTmpBillNumber"]>[0];
+type VendorInvoiceInsertOptions = Parameters<BillableOperator["insertOneVendorInvoice"]>[0];
+type VendorInvoiceReplaceOptions = Parameters<BillableOperator["replaceOneVendorInvoice"]>[0];
+type WarehouseInsertOptions = Parameters<BillableOperator["insertOneWarehouse"]>[0];
+type WarehouseReplaceOptions = Parameters<BillableOperator["replaceOneWarehouse"]>[0];
+type SearchBillableOptions = {
+    owner_id: string;
+    q?: string;
+    page?: number;
+    per_page?: number;
+};
+export type CreateBillOptions = BillInsertOptions;
+export type ReplaceBillOptions = BillReplaceOptions;
+export type SearchBillsOptions = SearchBillableOptions;
+export type SearchBillsPage = SearchPage<Bill>;
+export type CreateBillableFolderOptions = BillableFolderInsertOptions;
+export type ReplaceBillableFolderOptions = BillableFolderReplaceOptions;
+export type SearchBillableFoldersOptions = SearchBillableOptions;
+export type SearchBillableFoldersPage = SearchPage<BillableFolder>;
+export type CreateChargeOptions = ChargeInsertOptions;
+export type ReplaceChargeOptions = ChargeReplaceOptions;
+export type SearchChargesOptions = SearchBillableOptions;
+export type SearchChargesPage = SearchPage<Charge>;
+export type CreateEquipmentOptions = EquipmentInsertOptions;
+export type ReplaceEquipmentOptions = EquipmentReplaceOptions;
+export type SearchEquipmentsOptions = SearchBillableOptions;
+export type SearchEquipmentsPage = SearchPage<Equipment>;
+export type CreateItemOptions = ItemInsertOptions;
+export type ReplaceItemOptions = ItemReplaceOptions;
+export type SearchItemsOptions = SearchBillableOptions;
+export type SearchItemsPage = SearchPage<Item>;
+export type CreateLaborRateOptions = LaborRateInsertOptions;
+export type ReplaceLaborRateOptions = LaborRateReplaceOptions;
+export type SearchLaborRatesOptions = SearchBillableOptions;
+export type SearchLaborRatesPage = SearchPage<LaborRate>;
+export type CreateMeterReadingOptions = MeterReadingInsertOptions;
+export type ReplaceMeterReadingOptions = MeterReadingReplaceOptions;
+export type SearchMeterReadingsOptions = SearchBillableOptions;
+export type SearchMeterReadingsPage = SearchPage<MeterReading>;
+export type CreateQuantifierOptions = QuantifierInsertOptions;
+export type ReplaceQuantifierOptions = QuantifierReplaceOptions;
+export type SearchQuantifiersOptions = SearchBillableOptions;
+export type SearchQuantifiersPage = SearchPage<Quantifier>;
+export type CreateTaxOptions = TaxInsertOptions;
+export type ReplaceTaxOptions = TaxReplaceOptions;
+export type SearchTaxesOptions = SearchBillableOptions;
+export type SearchTaxesPage = SearchPage<Tax>;
+export type CreateTmpBillNumberOptions = TmpBillNumberInsertOptions;
+export type ReplaceTmpBillNumberOptions = TmpBillNumberReplaceOptions;
+export type SearchTmpBillNumbersOptions = SearchBillableOptions;
+export type SearchTmpBillNumbersPage = SearchPage<TmpBillNumber>;
+export type CreateVendorInvoiceOptions = VendorInvoiceInsertOptions;
+export type ReplaceVendorInvoiceOptions = VendorInvoiceReplaceOptions;
+export type SearchVendorInvoicesOptions = SearchBillableOptions;
+export type SearchVendorInvoicesPage = SearchPage<VendorInvoice>;
+export type CreateWarehouseOptions = WarehouseInsertOptions;
+export type ReplaceWarehouseOptions = WarehouseReplaceOptions;
+export type SearchWarehousesOptions = SearchBillableOptions;
+export type SearchWarehousesPage = SearchPage<Warehouse>;
 export type BillableFXOptions = {
     billable: BillableOperator;
 };
@@ -25,6 +104,42 @@ export type PeriodsFromDatesOptions = Parameters<BillableOperator["periodsFromDa
 export type VendorInvoiceFromBillOptions = Parameters<BillableOperator["vendorInvoiceFromBill"]>[0];
 export type SetItemQuantityOptions = Parameters<BillableOperator["setItemQuantity"]>[0];
 export interface BillableFXOperator {
+    createBill(opts: CreateBillOptions): Promise<Bill>;
+    replaceBill(opts: ReplaceBillOptions): Promise<Bill>;
+    searchBills(opts: SearchBillsOptions): Promise<SearchBillsPage>;
+    createBillableFolder(opts: CreateBillableFolderOptions): Promise<BillableFolder>;
+    replaceBillableFolder(opts: ReplaceBillableFolderOptions): Promise<BillableFolder>;
+    searchBillableFolders(opts: SearchBillableFoldersOptions): Promise<SearchBillableFoldersPage>;
+    createCharge(opts: CreateChargeOptions): Promise<Charge>;
+    replaceCharge(opts: ReplaceChargeOptions): Promise<Charge>;
+    searchCharges(opts: SearchChargesOptions): Promise<SearchChargesPage>;
+    createEquipment(opts: CreateEquipmentOptions): Promise<Equipment>;
+    replaceEquipment(opts: ReplaceEquipmentOptions): Promise<Equipment>;
+    searchEquipments(opts: SearchEquipmentsOptions): Promise<SearchEquipmentsPage>;
+    createItem(opts: CreateItemOptions): Promise<Item>;
+    replaceItem(opts: ReplaceItemOptions): Promise<Item>;
+    searchItems(opts: SearchItemsOptions): Promise<SearchItemsPage>;
+    createLaborRate(opts: CreateLaborRateOptions): Promise<LaborRate>;
+    replaceLaborRate(opts: ReplaceLaborRateOptions): Promise<LaborRate>;
+    searchLaborRates(opts: SearchLaborRatesOptions): Promise<SearchLaborRatesPage>;
+    createMeterReading(opts: CreateMeterReadingOptions): Promise<MeterReading>;
+    replaceMeterReading(opts: ReplaceMeterReadingOptions): Promise<MeterReading>;
+    searchMeterReadings(opts: SearchMeterReadingsOptions): Promise<SearchMeterReadingsPage>;
+    createQuantifier(opts: CreateQuantifierOptions): Promise<Quantifier>;
+    replaceQuantifier(opts: ReplaceQuantifierOptions): Promise<Quantifier>;
+    searchQuantifiers(opts: SearchQuantifiersOptions): Promise<SearchQuantifiersPage>;
+    createTax(opts: CreateTaxOptions): Promise<Tax>;
+    replaceTax(opts: ReplaceTaxOptions): Promise<Tax>;
+    searchTaxes(opts: SearchTaxesOptions): Promise<SearchTaxesPage>;
+    createTmpBillNumber(opts: CreateTmpBillNumberOptions): Promise<TmpBillNumber>;
+    replaceTmpBillNumber(opts: ReplaceTmpBillNumberOptions): Promise<TmpBillNumber>;
+    searchTmpBillNumbers(opts: SearchTmpBillNumbersOptions): Promise<SearchTmpBillNumbersPage>;
+    createVendorInvoice(opts: CreateVendorInvoiceOptions): Promise<VendorInvoice>;
+    replaceVendorInvoice(opts: ReplaceVendorInvoiceOptions): Promise<VendorInvoice>;
+    searchVendorInvoices(opts: SearchVendorInvoicesOptions): Promise<SearchVendorInvoicesPage>;
+    createWarehouse(opts: CreateWarehouseOptions): Promise<Warehouse>;
+    replaceWarehouse(opts: ReplaceWarehouseOptions): Promise<Warehouse>;
+    searchWarehouses(opts: SearchWarehousesOptions): Promise<SearchWarehousesPage>;
     generateFixedEstimate(opts: GenerateFixedEstimateOptions): Promise<OperationResult>;
     acceptFixedEstimate(opts: AcceptFixedEstimateOptions): Promise<OperationResult>;
     generateDynamicEstimate(opts: GenerateDynamicEstimateOptions): Promise<OperationResult>;
@@ -38,6 +153,42 @@ export interface BillableFXOperator {
 export declare class BillableFX implements BillableFXOperator {
     private billable;
     constructor(opts: BillableFXOptions);
+    createBill(opts: CreateBillOptions): Promise<Bill>;
+    replaceBill(opts: ReplaceBillOptions): Promise<Bill>;
+    searchBills(opts: SearchBillsOptions): Promise<SearchBillsPage>;
+    createBillableFolder(opts: CreateBillableFolderOptions): Promise<BillableFolder>;
+    replaceBillableFolder(opts: ReplaceBillableFolderOptions): Promise<BillableFolder>;
+    searchBillableFolders(opts: SearchBillableFoldersOptions): Promise<SearchBillableFoldersPage>;
+    createCharge(opts: CreateChargeOptions): Promise<Charge>;
+    replaceCharge(opts: ReplaceChargeOptions): Promise<Charge>;
+    searchCharges(opts: SearchChargesOptions): Promise<SearchChargesPage>;
+    createEquipment(opts: CreateEquipmentOptions): Promise<Equipment>;
+    replaceEquipment(opts: ReplaceEquipmentOptions): Promise<Equipment>;
+    searchEquipments(opts: SearchEquipmentsOptions): Promise<SearchEquipmentsPage>;
+    createItem(opts: CreateItemOptions): Promise<Item>;
+    replaceItem(opts: ReplaceItemOptions): Promise<Item>;
+    searchItems(opts: SearchItemsOptions): Promise<SearchItemsPage>;
+    createLaborRate(opts: CreateLaborRateOptions): Promise<LaborRate>;
+    replaceLaborRate(opts: ReplaceLaborRateOptions): Promise<LaborRate>;
+    searchLaborRates(opts: SearchLaborRatesOptions): Promise<SearchLaborRatesPage>;
+    createMeterReading(opts: CreateMeterReadingOptions): Promise<MeterReading>;
+    replaceMeterReading(opts: ReplaceMeterReadingOptions): Promise<MeterReading>;
+    searchMeterReadings(opts: SearchMeterReadingsOptions): Promise<SearchMeterReadingsPage>;
+    createQuantifier(opts: CreateQuantifierOptions): Promise<Quantifier>;
+    replaceQuantifier(opts: ReplaceQuantifierOptions): Promise<Quantifier>;
+    searchQuantifiers(opts: SearchQuantifiersOptions): Promise<SearchQuantifiersPage>;
+    createTax(opts: CreateTaxOptions): Promise<Tax>;
+    replaceTax(opts: ReplaceTaxOptions): Promise<Tax>;
+    searchTaxes(opts: SearchTaxesOptions): Promise<SearchTaxesPage>;
+    createTmpBillNumber(opts: CreateTmpBillNumberOptions): Promise<TmpBillNumber>;
+    replaceTmpBillNumber(opts: ReplaceTmpBillNumberOptions): Promise<TmpBillNumber>;
+    searchTmpBillNumbers(opts: SearchTmpBillNumbersOptions): Promise<SearchTmpBillNumbersPage>;
+    createVendorInvoice(opts: CreateVendorInvoiceOptions): Promise<VendorInvoice>;
+    replaceVendorInvoice(opts: ReplaceVendorInvoiceOptions): Promise<VendorInvoice>;
+    searchVendorInvoices(opts: SearchVendorInvoicesOptions): Promise<SearchVendorInvoicesPage>;
+    createWarehouse(opts: CreateWarehouseOptions): Promise<Warehouse>;
+    replaceWarehouse(opts: ReplaceWarehouseOptions): Promise<Warehouse>;
+    searchWarehouses(opts: SearchWarehousesOptions): Promise<SearchWarehousesPage>;
     generateFixedEstimate(opts: GenerateFixedEstimateOptions): Promise<OperationResult>;
     acceptFixedEstimate(opts: AcceptFixedEstimateOptions): Promise<OperationResult>;
     generateDynamicEstimate(opts: GenerateDynamicEstimateOptions): Promise<OperationResult>;
@@ -47,6 +198,18 @@ export declare class BillableFX implements BillableFXOperator {
     periodsFromDates(opts: PeriodsFromDatesOptions): Promise<OperationResultOf<RPBillablePeriodsFromDates>>;
     vendorInvoiceFromBill(opts: VendorInvoiceFromBillOptions): Promise<OperationResult>;
     setItemQuantity(opts: SetItemQuantityOptions): Promise<void>;
+    private findBill;
+    private findBillableFolder;
+    private findCharge;
+    private findEquipment;
+    private findItem;
+    private findLaborRate;
+    private findMeterReading;
+    private findQuantifier;
+    private findTax;
+    private findTmpBillNumber;
+    private findVendorInvoice;
+    private findWarehouse;
 }
 export declare function newBillableFX(opts: BillableFXOptions): BillableFX;
 export {};

package/dist/src/billable/billable.js

@@ -3,13 +3,293 @@
 // 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, } from "@fabriktor/schema";
+import { errResolveFailed } from "../core/err.js";
+import { requiredOperationID } from "../core/id.js";
+import { runSearch } from "../core/search.js";
 const billTypeFixed = "fixed";
 const billTypeDynamic = "dynamic";
+const resourceBill = "bill";
+const msgCreatedBillIDMissing = "Created bill response did not contain an ID.";
+const msgBillMissing = "Bill could not be resolved after the mutation.";
+const resourceBillableFolder = "billable_folder";
+const msgCreatedBillableFolderIDMissing = "Created billable folder response did not contain an ID.";
+const msgBillableFolderMissing = "Billable folder could not be resolved after the mutation.";
+const resourceCharge = "charge";
+const msgCreatedChargeIDMissing = "Created charge response did not contain an ID.";
+const msgChargeMissing = "Charge could not be resolved after the mutation.";
+const resourceEquipment = "equipment";
+const msgCreatedEquipmentIDMissing = "Created equipment response did not contain an ID.";
+const msgEquipmentMissing = "Equipment could not be resolved after the mutation.";
+const resourceItem = "item";
+const msgCreatedItemIDMissing = "Created item response did not contain an ID.";
+const msgItemMissing = "Item could not be resolved after the mutation.";
+const resourceLaborRate = "labor_rate";
+const msgCreatedLaborRateIDMissing = "Created labor rate response did not contain an ID.";
+const msgLaborRateMissing = "Labor rate could not be resolved after the mutation.";
+const resourceMeterReading = "meter_reading";
+const msgCreatedMeterReadingIDMissing = "Created meter reading response did not contain an ID.";
+const msgMeterReadingMissing = "Meter reading could not be resolved after the mutation.";
+const resourceQuantifier = "quantifier";
+const msgCreatedQuantifierIDMissing = "Created quantifier response did not contain an ID.";
+const msgQuantifierMissing = "Quantifier could not be resolved after the mutation.";
+const resourceTax = "tax";
+const msgCreatedTaxIDMissing = "Created tax response did not contain an ID.";
+const msgTaxMissing = "Tax could not be resolved after the mutation.";
+const resourceTmpBillNumber = "tmp_bill_number";
+const msgCreatedTmpBillNumberIDMissing = "Created tmp bill number response did not contain an ID.";
+const msgTmpBillNumberMissing = "Tmp bill number could not be resolved after the mutation.";
+const resourceVendorInvoice = "vendor_invoice";
+const msgCreatedVendorInvoiceIDMissing = "Created vendor invoice response did not contain an ID.";
+const msgVendorInvoiceMissing = "Vendor invoice could not be resolved after the mutation.";
+const resourceWarehouse = "warehouse";
+const msgCreatedWarehouseIDMissing = "Created warehouse response did not contain an ID.";
+const msgWarehouseMissing = "Warehouse could not be resolved after the mutation.";
 export class BillableFX {
     billable;
     constructor(opts) {
         this.billable = opts.billable;
     }
+    async createBill(opts) {
+        const out = await this.billable.insertOneBill(opts);
+        const id = requiredOperationID(out, msgCreatedBillIDMissing);
+        return await this.findBill(id);
+    }
+    async replaceBill(opts) {
+        await this.billable.replaceOneBill(opts);
+        return await this.findBill(opts.id);
+    }
+    async searchBills(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.billable.searchManyBills(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createBillableFolder(opts) {
+        const out = await this.billable.insertOneBillableFolder(opts);
+        const id = requiredOperationID(out, msgCreatedBillableFolderIDMissing);
+        return await this.findBillableFolder(id);
+    }
+    async replaceBillableFolder(opts) {
+        await this.billable.replaceOneBillableFolder(opts);
+        return await this.findBillableFolder(opts.id);
+    }
+    async searchBillableFolders(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.billable.searchManyBillableFolders(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createCharge(opts) {
+        const out = await this.billable.insertOneCharge(opts);
+        const id = requiredOperationID(out, msgCreatedChargeIDMissing);
+        return await this.findCharge(id);
+    }
+    async replaceCharge(opts) {
+        await this.billable.replaceOneCharge(opts);
+        return await this.findCharge(opts.id);
+    }
+    async searchCharges(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.billable.searchManyCharges(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createEquipment(opts) {
+        const out = await this.billable.insertOneEquipment(opts);
+        const id = requiredOperationID(out, msgCreatedEquipmentIDMissing);
+        return await this.findEquipment(id);
+    }
+    async replaceEquipment(opts) {
+        await this.billable.replaceOneEquipment(opts);
+        return await this.findEquipment(opts.id);
+    }
+    async searchEquipments(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.billable.searchManyEquipments(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createItem(opts) {
+        const out = await this.billable.insertOneItem(opts);
+        const id = requiredOperationID(out, msgCreatedItemIDMissing);
+        return await this.findItem(id);
+    }
+    async replaceItem(opts) {
+        await this.billable.replaceOneItem(opts);
+        return await this.findItem(opts.id);
+    }
+    async searchItems(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.billable.searchManyItems(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createLaborRate(opts) {
+        const out = await this.billable.insertOneLaborRate(opts);
+        const id = requiredOperationID(out, msgCreatedLaborRateIDMissing);
+        return await this.findLaborRate(id);
+    }
+    async replaceLaborRate(opts) {
+        await this.billable.replaceOneLaborRate(opts);
+        return await this.findLaborRate(opts.id);
+    }
+    async searchLaborRates(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.billable.searchManyLaborRates(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createMeterReading(opts) {
+        const out = await this.billable.insertOneMeterReading(opts);
+        const id = requiredOperationID(out, msgCreatedMeterReadingIDMissing);
+        return await this.findMeterReading(id);
+    }
+    async replaceMeterReading(opts) {
+        await this.billable.replaceOneMeterReading(opts);
+        return await this.findMeterReading(opts.id);
+    }
+    async searchMeterReadings(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.billable.searchManyMeterReadings(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createQuantifier(opts) {
+        const out = await this.billable.insertOneQuantifier(opts);
+        const id = requiredOperationID(out, msgCreatedQuantifierIDMissing);
+        return await this.findQuantifier(id);
+    }
+    async replaceQuantifier(opts) {
+        await this.billable.replaceOneQuantifier(opts);
+        return await this.findQuantifier(opts.id);
+    }
+    async searchQuantifiers(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.billable.searchManyQuantifiers(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createTax(opts) {
+        const out = await this.billable.insertOneTax(opts);
+        const id = requiredOperationID(out, msgCreatedTaxIDMissing);
+        return await this.findTax(id);
+    }
+    async replaceTax(opts) {
+        await this.billable.replaceOneTax(opts);
+        return await this.findTax(opts.id);
+    }
+    async searchTaxes(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.billable.searchManyTaxes(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createTmpBillNumber(opts) {
+        const out = await this.billable.insertOneTmpBillNumber(opts);
+        const id = requiredOperationID(out, msgCreatedTmpBillNumberIDMissing);
+        return await this.findTmpBillNumber(id);
+    }
+    async replaceTmpBillNumber(opts) {
+        await this.billable.replaceOneTmpBillNumber(opts);
+        return await this.findTmpBillNumber(opts.id);
+    }
+    async searchTmpBillNumbers(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.billable.searchManyTmpBillNumbers(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createVendorInvoice(opts) {
+        const out = await this.billable.insertOneVendorInvoice(opts);
+        const id = requiredOperationID(out, msgCreatedVendorInvoiceIDMissing);
+        return await this.findVendorInvoice(id);
+    }
+    async replaceVendorInvoice(opts) {
+        await this.billable.replaceOneVendorInvoice(opts);
+        return await this.findVendorInvoice(opts.id);
+    }
+    async searchVendorInvoices(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.billable.searchManyVendorInvoices(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createWarehouse(opts) {
+        const out = await this.billable.insertOneWarehouse(opts);
+        const id = requiredOperationID(out, msgCreatedWarehouseIDMissing);
+        return await this.findWarehouse(id);
+    }
+    async replaceWarehouse(opts) {
+        await this.billable.replaceOneWarehouse(opts);
+        return await this.findWarehouse(opts.id);
+    }
+    async searchWarehouses(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.billable.searchManyWarehouses(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
     async generateFixedEstimate(opts) {
         return await this.billable.generateBill(billWith(opts.in, {
             type: billTypeFixed,
@@ -52,6 +332,162 @@ export class BillableFX {
     async setItemQuantity(opts) {
         await this.billable.setItemQuantity(opts);
     }
+    async findBill(id) {
+        const out = await this.billable.findOneBill({
+            id,
+        });
+        const value = out.value;
+        if (value === undefined) {
+            throw errResolveFailed({
+                resource: resourceBill,
+                msg: msgBillMissing,
+            });
+        }
+        return value;
+    }
+    async findBillableFolder(id) {
+        const out = await this.billable.findOneBillableFolder({
+            id,
+        });
+        const value = out.value;
+        if (value === undefined) {
+            throw errResolveFailed({
+                resource: resourceBillableFolder,
+                msg: msgBillableFolderMissing,
+            });
+        }
+        return value;
+    }
+    async findCharge(id) {
+        const out = await this.billable.findOneCharge({
+            id,
+        });
+        const value = out.value;
+        if (value === undefined) {
+            throw errResolveFailed({
+                resource: resourceCharge,
+                msg: msgChargeMissing,
+            });
+        }
+        return value;
+    }
+    async findEquipment(id) {
+        const out = await this.billable.findOneEquipment({
+            id,
+        });
+        const value = out.value;
+        if (value === undefined) {
+            throw errResolveFailed({
+                resource: resourceEquipment,
+                msg: msgEquipmentMissing,
+            });
+        }
+        return value;
+    }
+    async findItem(id) {
+        const out = await this.billable.findOneItem({
+            id,
+        });
+        const value = out.value;
+        if (value === undefined) {
+            throw errResolveFailed({
+                resource: resourceItem,
+                msg: msgItemMissing,
+            });
+        }
+        return value;
+    }
+    async findLaborRate(id) {
+        const out = await this.billable.findOneLaborRate({
+            id,
+        });
+        const value = out.value;
+        if (value === undefined) {
+            throw errResolveFailed({
+                resource: resourceLaborRate,
+                msg: msgLaborRateMissing,
+            });
+        }
+        return value;
+    }
+    async findMeterReading(id) {
+        const out = await this.billable.findOneMeterReading({
+            id,
+        });
+        const value = out.value;
+        if (value === undefined) {
+            throw errResolveFailed({
+                resource: resourceMeterReading,
+                msg: msgMeterReadingMissing,
+            });
+        }
+        return value;
+    }
+    async findQuantifier(id) {
+        const out = await this.billable.findOneQuantifier({
+            id,
+        });
+        const value = out.value;
+        if (value === undefined) {
+            throw errResolveFailed({
+                resource: resourceQuantifier,
+                msg: msgQuantifierMissing,
+            });
+        }
+        return value;
+    }
+    async findTax(id) {
+        const out = await this.billable.findOneTax({
+            id,
+        });
+        const value = out.value;
+        if (value === undefined) {
+            throw errResolveFailed({
+                resource: resourceTax,
+                msg: msgTaxMissing,
+            });
+        }
+        return value;
+    }
+    async findTmpBillNumber(id) {
+        const out = await this.billable.findOneTmpBillNumber({
+            id,
+        });
+        const value = out.value;
+        if (value === undefined) {
+            throw errResolveFailed({
+                resource: resourceTmpBillNumber,
+                msg: msgTmpBillNumberMissing,
+            });
+        }
+        return value;
+    }
+    async findVendorInvoice(id) {
+        const out = await this.billable.findOneVendorInvoice({
+            id,
+        });
+        const value = out.value;
+        if (value === undefined) {
+            throw errResolveFailed({
+                resource: resourceVendorInvoice,
+                msg: msgVendorInvoiceMissing,
+            });
+        }
+        return value;
+    }
+    async findWarehouse(id) {
+        const out = await this.billable.findOneWarehouse({
+            id,
+        });
+        const value = out.value;
+        if (value === undefined) {
+            throw errResolveFailed({
+                resource: resourceWarehouse,
+                msg: msgWarehouseMissing,
+            });
+        }
+        return value;
+    }
 }
 export function newBillableFX(opts) {
     return new BillableFX(opts);

package/dist/src/calls/calls.d.ts

@@ -1,4 +1,9 @@
 import type { CallsOperator, NotificationsOperator } from "@fabriktor/client";
+import type { Event } from "@fabriktor/schema";
+type EventInsertOptions = Parameters<CallsOperator["insertOneEvent"]>[0];
+type EventReplaceOptions = Parameters<CallsOperator["replaceOneEvent"]>[0];
+export type CreateEventOptions = EventInsertOptions;
+export type ReplaceEventOptions = EventReplaceOptions;
 export type MintVideoTokenOptions = Parameters<CallsOperator["mintVideoToken"]>[0];
 export type RelayNotificationOptions = Parameters<NotificationsOperator["relayNotification"]>[0];
 export type StartCallOptions = {
@@ -17,6 +22,8 @@ export type CallsFXOptions = {
     notifications: NotificationsOperator;
 };
 export interface CallsFXOperator {
+    createEvent(opts: CreateEventOptions): Promise<Event>;
+    replaceEvent(opts: ReplaceEventOptions): Promise<Event>;
     startCall(opts: StartCallOptions): Promise<string>;
     answerCall(opts: AnswerCallOptions): Promise<string>;
     cancelCall(opts: CancelCallOptions): Promise<void>;
@@ -25,9 +32,13 @@ export declare class CallsFX implements CallsFXOperator {
     private calls;
     private notifications;
     constructor(opts: CallsFXOptions);
+    createEvent(opts: CreateEventOptions): Promise<Event>;
+    replaceEvent(opts: ReplaceEventOptions): Promise<Event>;
     startCall(opts: StartCallOptions): Promise<string>;
     answerCall(opts: AnswerCallOptions): Promise<string>;
     cancelCall(opts: CancelCallOptions): Promise<void>;
+    private findEvent;
     private requireVideoToken;
 }
 export declare function newCallsFX(opts: CallsFXOptions): CallsFX;
+export {};