@fabriktor/fx 0.0.39 → 0.0.40

package/dist/src/preferences/preferences.js

@@ -4,11 +4,121 @@
 // 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 { queryParam } from "@fabriktor/client";
+import { errResolveFailed } from "../core/err.js";
+import { requiredOperationID } from "../core/id.js";
+const resourcePrefPayment = "pref_payment";
+const msgCreatedPrefPaymentIDMissing = "Created preference payment response did not contain an ID.";
+const msgPrefPaymentMissing = "Preference payment could not be resolved after the mutation.";
+const resourcePrefClient = "pref_client";
+const msgCreatedPrefClientIDMissing = "Created client preference response did not contain an ID.";
+const msgPrefClientMissing = "Client preference could not be resolved after the mutation.";
+const resourcePrefEmployee = "pref_employee";
+const msgCreatedPrefEmployeeIDMissing = "Created employee preference response did not contain an ID.";
+const msgPrefEmployeeMissing = "Employee preference could not be resolved after the mutation.";
+const resourcePrefCompany = "pref_company";
+const msgCreatedPrefCompanyIDMissing = "Created company preference response did not contain an ID.";
+const msgPrefCompanyMissing = "Company preference could not be resolved after the mutation.";
+const resourcePrefVisibility = "pref_visibility";
+const msgCreatedPrefVisibilityIDMissing = "Created visibility preference response did not contain an ID.";
+const msgPrefVisibilityMissing = "Visibility preference could not be resolved after the mutation.";
+const resourcePrefLanguage = "pref_language";
+const msgCreatedPrefLanguageIDMissing = "Created language preference response did not contain an ID.";
+const msgPrefLanguageMissing = "Language preference could not be resolved after the mutation.";
+const resourcePrefNotif = "pref_notif";
+const msgCreatedPrefNotifIDMissing = "Created notification preference response did not contain an ID.";
+const msgPrefNotifMissing = "Notification preference could not be resolved after the mutation.";
+const resourcePrefEmail = "pref_email";
+const msgCreatedPrefEmailIDMissing = "Created email preference response did not contain an ID.";
+const msgPrefEmailMissing = "Email preference could not be resolved after the mutation.";
+const resourcePrefTutorial = "pref_tutorial";
+const msgCreatedPrefTutorialIDMissing = "Created tutorial preference response did not contain an ID.";
+const msgPrefTutorialMissing = "Tutorial preference could not be resolved after the mutation.";
 export class PreferencesFX {
     preferences;
     constructor(opts) {
         this.preferences = opts.preferences;
     }
+    async createPrefPayment(opts) {
+        const out = await this.preferences.insertOnePrefPayment(opts);
+        const id = requiredOperationID(out, msgCreatedPrefPaymentIDMissing);
+        return await this.findPrefPayment(id);
+    }
+    async replacePrefPayment(opts) {
+        await this.preferences.replaceOnePrefPayment(opts);
+        return await this.findPrefPayment(opts.id);
+    }
+    async createPrefClient(opts) {
+        const out = await this.preferences.insertOnePrefClient(opts);
+        const id = requiredOperationID(out, msgCreatedPrefClientIDMissing);
+        return await this.findPrefClient(id);
+    }
+    async replacePrefClient(opts) {
+        await this.preferences.replaceOnePrefClient(opts);
+        return await this.findPrefClient(opts.id);
+    }
+    async createPrefEmployee(opts) {
+        const out = await this.preferences.insertOnePrefEmployee(opts);
+        const id = requiredOperationID(out, msgCreatedPrefEmployeeIDMissing);
+        return await this.findPrefEmployee(id);
+    }
+    async replacePrefEmployee(opts) {
+        await this.preferences.replaceOnePrefEmployee(opts);
+        return await this.findPrefEmployee(opts.id);
+    }
+    async createPrefCompany(opts) {
+        const out = await this.preferences.insertOnePrefCompany(opts);
+        const id = requiredOperationID(out, msgCreatedPrefCompanyIDMissing);
+        return await this.findPrefCompany(id);
+    }
+    async replacePrefCompany(opts) {
+        await this.preferences.replaceOnePrefCompany(opts);
+        return await this.findPrefCompany(opts.id);
+    }
+    async createPrefVisibility(opts) {
+        const out = await this.preferences.insertOnePrefVisibility(opts);
+        const id = requiredOperationID(out, msgCreatedPrefVisibilityIDMissing);
+        return await this.findPrefVisibility(id);
+    }
+    async replacePrefVisibility(opts) {
+        await this.preferences.replaceOnePrefVisibility(opts);
+        return await this.findPrefVisibility(opts.id);
+    }
+    async createPrefLanguage(opts) {
+        const out = await this.preferences.insertOnePrefLanguage(opts);
+        const id = requiredOperationID(out, msgCreatedPrefLanguageIDMissing);
+        return await this.findPrefLanguage(id);
+    }
+    async replacePrefLanguage(opts) {
+        await this.preferences.replaceOnePrefLanguage(opts);
+        return await this.findPrefLanguage(opts.id);
+    }
+    async createPrefNotif(opts) {
+        const out = await this.preferences.insertOnePrefNotif(opts);
+        const id = requiredOperationID(out, msgCreatedPrefNotifIDMissing);
+        return await this.findPrefNotif(id);
+    }
+    async replacePrefNotif(opts) {
+        await this.preferences.replaceOnePrefNotif(opts);
+        return await this.findPrefNotif(opts.id);
+    }
+    async createPrefEmail(opts) {
+        const out = await this.preferences.insertOnePrefEmail(opts);
+        const id = requiredOperationID(out, msgCreatedPrefEmailIDMissing);
+        return await this.findPrefEmail(id);
+    }
+    async replacePrefEmail(opts) {
+        await this.preferences.replaceOnePrefEmail(opts);
+        return await this.findPrefEmail(opts.id);
+    }
+    async createPrefTutorial(opts) {
+        const out = await this.preferences.insertOnePrefTutorial(opts);
+        const id = requiredOperationID(out, msgCreatedPrefTutorialIDMissing);
+        return await this.findPrefTutorial(id);
+    }
+    async replacePrefTutorial(opts) {
+        await this.preferences.replaceOnePrefTutorial(opts);
+        return await this.findPrefTutorial(opts.id);
+    }
     async ensurePrefLanguage(opts) {
         const out = await this.preferences.queryPrefLanguages({
             query: queryParam("owner_id", opts.owner_id),
@@ -40,6 +150,123 @@ export class PreferencesFX {
             in: input,
         });
     }
+    async findPrefPayment(id) {
+        const out = await this.preferences.findOnePrefPayment({
+            id,
+        });
+        const pref_payment = out.value;
+        if (pref_payment === undefined) {
+            throw errResolveFailed({
+                resource: resourcePrefPayment,
+                msg: msgPrefPaymentMissing,
+            });
+        }
+        return pref_payment;
+    }
+    async findPrefClient(id) {
+        const out = await this.preferences.findOnePrefClient({
+            id,
+        });
+        const pref_client = out.value;
+        if (pref_client === undefined) {
+            throw errResolveFailed({
+                resource: resourcePrefClient,
+                msg: msgPrefClientMissing,
+            });
+        }
+        return pref_client;
+    }
+    async findPrefEmployee(id) {
+        const out = await this.preferences.findOnePrefEmployee({
+            id,
+        });
+        const pref_employee = out.value;
+        if (pref_employee === undefined) {
+            throw errResolveFailed({
+                resource: resourcePrefEmployee,
+                msg: msgPrefEmployeeMissing,
+            });
+        }
+        return pref_employee;
+    }
+    async findPrefCompany(id) {
+        const out = await this.preferences.findOnePrefCompany({
+            id,
+        });
+        const pref_company = out.value;
+        if (pref_company === undefined) {
+            throw errResolveFailed({
+                resource: resourcePrefCompany,
+                msg: msgPrefCompanyMissing,
+            });
+        }
+        return pref_company;
+    }
+    async findPrefVisibility(id) {
+        const out = await this.preferences.findOnePrefVisibility({
+            id,
+        });
+        const pref_visibility = out.value;
+        if (pref_visibility === undefined) {
+            throw errResolveFailed({
+                resource: resourcePrefVisibility,
+                msg: msgPrefVisibilityMissing,
+            });
+        }
+        return pref_visibility;
+    }
+    async findPrefLanguage(id) {
+        const out = await this.preferences.findOnePrefLanguage({
+            id,
+        });
+        const pref_language = out.value;
+        if (pref_language === undefined) {
+            throw errResolveFailed({
+                resource: resourcePrefLanguage,
+                msg: msgPrefLanguageMissing,
+            });
+        }
+        return pref_language;
+    }
+    async findPrefNotif(id) {
+        const out = await this.preferences.findOnePrefNotif({
+            id,
+        });
+        const pref_notif = out.value;
+        if (pref_notif === undefined) {
+            throw errResolveFailed({
+                resource: resourcePrefNotif,
+                msg: msgPrefNotifMissing,
+            });
+        }
+        return pref_notif;
+    }
+    async findPrefEmail(id) {
+        const out = await this.preferences.findOnePrefEmail({
+            id,
+        });
+        const pref_email = out.value;
+        if (pref_email === undefined) {
+            throw errResolveFailed({
+                resource: resourcePrefEmail,
+                msg: msgPrefEmailMissing,
+            });
+        }
+        return pref_email;
+    }
+    async findPrefTutorial(id) {
+        const out = await this.preferences.findOnePrefTutorial({
+            id,
+        });
+        const pref_tutorial = out.value;
+        if (pref_tutorial === undefined) {
+            throw errResolveFailed({
+                resource: resourcePrefTutorial,
+                msg: msgPrefTutorialMissing,
+            });
+        }
+        return pref_tutorial;
+    }
 }
 export function newPreferencesFX(opts) {
     return new PreferencesFX(opts);

package/dist/src/privacy/privacy.d.ts

@@ -1,5 +1,13 @@
-import { type AccountLock } from "@fabriktor/schema";
 import type { PrivacyOperator } from "@fabriktor/client";
+import { type AccountLock, type DeletionRequest } from "@fabriktor/schema";
+type DeletionRequestInsertOptions = Parameters<PrivacyOperator["insertOneDeletionRequest"]>[0];
+type DeletionRequestReplaceOptions = Parameters<PrivacyOperator["replaceOneDeletionRequest"]>[0];
+type AccountLockInsertOptions = Parameters<PrivacyOperator["insertOneAccountLock"]>[0];
+type AccountLockReplaceOptions = Parameters<PrivacyOperator["replaceOneAccountLock"]>[0];
+export type CreateDeletionRequestOptions = DeletionRequestInsertOptions;
+export type ReplaceDeletionRequestOptions = DeletionRequestReplaceOptions;
+export type CreateAccountLockOptions = AccountLockInsertOptions;
+export type ReplaceAccountLockOptions = AccountLockReplaceOptions;
 export type PrivacyFXOptions = {
     privacy: PrivacyOperator;
 };
@@ -10,12 +18,23 @@ export type WatchAccountLockOptions = {
 };
 export type StopAccountLockWatch = () => void;
 export interface PrivacyFXOperator {
+    createDeletionRequest(opts: CreateDeletionRequestOptions): Promise<DeletionRequest>;
+    replaceDeletionRequest(opts: ReplaceDeletionRequestOptions): Promise<DeletionRequest>;
+    createAccountLock(opts: CreateAccountLockOptions): Promise<AccountLock>;
+    replaceAccountLock(opts: ReplaceAccountLockOptions): Promise<AccountLock>;
     watchAccountLock(opts: WatchAccountLockOptions): Promise<StopAccountLockWatch>;
 }
 export declare class PrivacyFX implements PrivacyFXOperator {
     private privacy;
     constructor(opts: PrivacyFXOptions);
+    createDeletionRequest(opts: CreateDeletionRequestOptions): Promise<DeletionRequest>;
+    replaceDeletionRequest(opts: ReplaceDeletionRequestOptions): Promise<DeletionRequest>;
+    createAccountLock(opts: CreateAccountLockOptions): Promise<AccountLock>;
+    replaceAccountLock(opts: ReplaceAccountLockOptions): Promise<AccountLock>;
     watchAccountLock(opts: WatchAccountLockOptions): Promise<StopAccountLockWatch>;
-    private findAccountLock;
+    private resolveDeletionRequest;
+    private resolveAccountLock;
+    private findOwnerAccountLock;
 }
 export declare function newPrivacyFX(opts: PrivacyFXOptions): PrivacyFX;
+export {};

package/dist/src/privacy/privacy.js

@@ -3,15 +3,40 @@
 // 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";
+import { ZeroID, } from "@fabriktor/schema";
+import { errRequired, errResolveFailed, } from "../core/err.js";
+import { requiredOperationID } from "../core/id.js";
 const accountLockIntervalMs = 60 * 60 * 1000;
+const resourceDeletionRequest = "deletion_request";
+const resourceAccountLock = "account_lock";
 const msgOwnerIDRequired = "Owner ID is required.";
+const msgCreatedDeletionRequestIDMissing = "Created deletion request response did not contain an ID.";
+const msgDeletionRequestMissing = "Deletion request could not be resolved after the mutation.";
+const msgCreatedAccountLockIDMissing = "Created account lock response did not contain an ID.";
+const msgAccountLockMissing = "Account lock could not be resolved after the mutation.";
 export class PrivacyFX {
     privacy;
     constructor(opts) {
         this.privacy = opts.privacy;
     }
+    async createDeletionRequest(opts) {
+        const out = await this.privacy.insertOneDeletionRequest(opts);
+        const id = requiredOperationID(out, msgCreatedDeletionRequestIDMissing);
+        return await this.resolveDeletionRequest(id);
+    }
+    async replaceDeletionRequest(opts) {
+        await this.privacy.replaceOneDeletionRequest(opts);
+        return await this.resolveDeletionRequest(opts.id);
+    }
+    async createAccountLock(opts) {
+        const out = await this.privacy.insertOneAccountLock(opts);
+        const id = requiredOperationID(out, msgCreatedAccountLockIDMissing);
+        return await this.resolveAccountLock(id);
+    }
+    async replaceAccountLock(opts) {
+        await this.privacy.replaceOneAccountLock(opts);
+        return await this.resolveAccountLock(opts.id);
+    }
     async watchAccountLock(opts) {
         const owner_id = opts.owner_id.trim();
         if (owner_id === "" || owner_id === ZeroID) {
@@ -20,7 +45,7 @@ export class PrivacyFX {
                 msg: msgOwnerIDRequired,
             });
         }
-        const initial_lock = await this.findAccountLock(owner_id);
+        const initial_lock = await this.findOwnerAccountLock(owner_id);
         if (initial_lock !== undefined) {
             opts.on_lock(initial_lock);
             return () => { };
@@ -37,7 +62,7 @@ export class PrivacyFX {
                 return;
             }
             try {
-                const lock = await this.findAccountLock(owner_id);
+                const lock = await this.findOwnerAccountLock(owner_id);
                 if (stopped) {
                     return;
                 }
@@ -64,7 +89,33 @@ export class PrivacyFX {
             }
         };
     }
-    async findAccountLock(owner_id) {
+    async resolveDeletionRequest(id) {
+        const out = await this.privacy.findOneDeletionRequest({
+            id,
+        });
+        const deletion_request = out.value;
+        if (deletion_request === undefined) {
+            throw errResolveFailed({
+                resource: resourceDeletionRequest,
+                msg: msgDeletionRequestMissing,
+            });
+        }
+        return deletion_request;
+    }
+    async resolveAccountLock(id) {
+        const out = await this.privacy.findOneAccountLock({
+            id,
+        });
+        const account_lock = out.value;
+        if (account_lock === undefined) {
+            throw errResolveFailed({
+                resource: resourceAccountLock,
+                msg: msgAccountLockMissing,
+            });
+        }
+        return account_lock;
+    }
+    async findOwnerAccountLock(owner_id) {
         const out = await this.privacy.queryAccountLocks({
             query: {
                 owner_id,

package/dist/src/routes/routes.d.ts

@@ -1,22 +1,82 @@
 import type { RoutesOperator } from "@fabriktor/client";
+import { type ClientAvailability, type Route, type RouteTeam, type Tag, type Tracking } from "@fabriktor/schema";
+import { type SearchPage } from "../core/search.js";
 type RouteInsertOptions = Parameters<RoutesOperator["insertOneRoute"]>[0];
+type RouteReplaceOptions = Parameters<RoutesOperator["replaceOneRoute"]>[0];
+type TagInsertOptions = Parameters<RoutesOperator["insertOneTag"]>[0];
+type TagReplaceOptions = Parameters<RoutesOperator["replaceOneTag"]>[0];
+type ClientAvailabilityInsertOptions = Parameters<RoutesOperator["insertOneClientAvailability"]>[0];
+type ClientAvailabilityReplaceOptions = Parameters<RoutesOperator["replaceOneClientAvailability"]>[0];
+type TrackingInsertOptions = Parameters<RoutesOperator["insertOneTracking"]>[0];
+type TrackingReplaceOptions = Parameters<RoutesOperator["replaceOneTracking"]>[0];
+type RouteTeamInsertOptions = Parameters<RoutesOperator["insertOneRouteTeam"]>[0];
+type RouteTeamReplaceOptions = Parameters<RoutesOperator["replaceOneRouteTeam"]>[0];
 type RouteInsert = RouteInsertOptions["in"];
 type RouteAvailability = NonNullable<Awaited<ReturnType<RoutesOperator["getAvailability"]>>["value"]>;
+type SearchRouteRecordsOptions = {
+    owner_id: string;
+    q?: string;
+    page?: number;
+    per_page?: number;
+};
 export type CreateRouteOptions = {
     in: RouteInsert;
     availability: RouteAvailability;
 };
-export type CreateRouteResult = Awaited<ReturnType<RoutesOperator["insertOneRoute"]>>;
+export type CreateValidatedRouteResult = Awaited<ReturnType<RoutesOperator["insertOneRoute"]>>;
+export type CreateRouteResult = CreateValidatedRouteResult;
+export type ReplaceRouteOptions = RouteReplaceOptions;
+export type CreateTagOptions = TagInsertOptions;
+export type ReplaceTagOptions = TagReplaceOptions;
+export type SearchTagsOptions = SearchRouteRecordsOptions;
+export type SearchTagsPage = SearchPage<Tag>;
+export type CreateClientAvailabilityOptions = ClientAvailabilityInsertOptions;
+export type ReplaceClientAvailabilityOptions = ClientAvailabilityReplaceOptions;
+export type CreateTrackingOptions = TrackingInsertOptions;
+export type ReplaceTrackingOptions = TrackingReplaceOptions;
+export type CreateRouteTeamOptions = RouteTeamInsertOptions;
+export type ReplaceRouteTeamOptions = RouteTeamReplaceOptions;
+export type SearchRouteTeamsOptions = SearchRouteRecordsOptions;
+export type SearchRouteTeamsPage = SearchPage<RouteTeam>;
 export type RoutesFXOptions = {
     routes: RoutesOperator;
 };
 export interface RoutesFXOperator {
-    createRoute(opts: CreateRouteOptions): Promise<CreateRouteResult>;
+    createRoute(opts: CreateRouteOptions): Promise<Route>;
+    createValidatedRoute(opts: CreateRouteOptions): Promise<CreateValidatedRouteResult>;
+    replaceRoute(opts: ReplaceRouteOptions): Promise<Route>;
+    createTag(opts: CreateTagOptions): Promise<Tag>;
+    replaceTag(opts: ReplaceTagOptions): Promise<Tag>;
+    searchTags(opts: SearchTagsOptions): Promise<SearchTagsPage>;
+    createClientAvailability(opts: CreateClientAvailabilityOptions): Promise<ClientAvailability>;
+    replaceClientAvailability(opts: ReplaceClientAvailabilityOptions): Promise<ClientAvailability>;
+    createTracking(opts: CreateTrackingOptions): Promise<Tracking>;
+    replaceTracking(opts: ReplaceTrackingOptions): Promise<Tracking>;
+    createRouteTeam(opts: CreateRouteTeamOptions): Promise<RouteTeam>;
+    replaceRouteTeam(opts: ReplaceRouteTeamOptions): Promise<RouteTeam>;
+    searchRouteTeams(opts: SearchRouteTeamsOptions): Promise<SearchRouteTeamsPage>;
 }
 export declare class RoutesFX implements RoutesFXOperator {
     private routes;
     constructor(opts: RoutesFXOptions);
-    createRoute(opts: CreateRouteOptions): Promise<CreateRouteResult>;
+    createRoute(opts: CreateRouteOptions): Promise<Route>;
+    createValidatedRoute(opts: CreateRouteOptions): Promise<CreateValidatedRouteResult>;
+    replaceRoute(opts: ReplaceRouteOptions): Promise<Route>;
+    createTag(opts: CreateTagOptions): Promise<Tag>;
+    replaceTag(opts: ReplaceTagOptions): Promise<Tag>;
+    searchTags(opts: SearchTagsOptions): Promise<SearchTagsPage>;
+    createClientAvailability(opts: CreateClientAvailabilityOptions): Promise<ClientAvailability>;
+    replaceClientAvailability(opts: ReplaceClientAvailabilityOptions): Promise<ClientAvailability>;
+    createTracking(opts: CreateTrackingOptions): Promise<Tracking>;
+    replaceTracking(opts: ReplaceTrackingOptions): Promise<Tracking>;
+    createRouteTeam(opts: CreateRouteTeamOptions): Promise<RouteTeam>;
+    replaceRouteTeam(opts: ReplaceRouteTeamOptions): Promise<RouteTeam>;
+    searchRouteTeams(opts: SearchRouteTeamsOptions): Promise<SearchRouteTeamsPage>;
+    private findRoute;
+    private findTag;
+    private findClientAvailability;
+    private findTracking;
+    private findRouteTeam;
 }
 export declare function newRoutesFX(opts: RoutesFXOptions): RoutesFX;
 export {};

package/dist/src/routes/routes.js

@@ -3,10 +3,28 @@
 // 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 { errValidation } from "../core/err.js";
+import { OwnerIDKey, } from "@fabriktor/schema";
+import { errResolveFailed, errValidation } from "../core/err.js";
+import { requiredOperationID } from "../core/id.js";
+import { runSearch } from "../core/search.js";
 const maxHour = 23;
 const maxMinute = 59;
 const maxMinuteOfDay = 1440;
+const resourceRoute = "route";
+const resourceTag = "tag";
+const resourceClientAvailability = "client_availability";
+const resourceTracking = "tracking";
+const resourceRouteTeam = "route_team";
+const msgCreatedRouteIDMissing = "Created route response did not contain an ID.";
+const msgRouteMissing = "Route could not be resolved after the mutation.";
+const msgCreatedTagIDMissing = "Created tag response did not contain an ID.";
+const msgTagMissing = "Tag could not be resolved after the mutation.";
+const msgCreatedClientAvailabilityIDMissing = "Created client availability response did not contain an ID.";
+const msgClientAvailabilityMissing = "Client availability could not be resolved after the mutation.";
+const msgCreatedTrackingIDMissing = "Created tracking response did not contain an ID.";
+const msgTrackingMissing = "Tracking could not be resolved after the mutation.";
+const msgCreatedRouteTeamIDMissing = "Created route team response did not contain an ID.";
+const msgRouteTeamMissing = "Route team could not be resolved after the mutation.";
 const msgGlobalWindowSameDay = "The global route window must stay within one calendar day.";
 const msgGlobalWindowInvalid = "The global route window is invalid.";
 const msgEmployeeDuplicate = "An employee cannot be selected in more than one vehicle.";
@@ -21,11 +39,143 @@ export class RoutesFX {
         this.routes = opts.routes;
     }
     async createRoute(opts) {
+        const out = await this.createValidatedRoute(opts);
+        const id = requiredOperationID(out, msgCreatedRouteIDMissing);
+        return await this.findRoute(id);
+    }
+    async createValidatedRoute(opts) {
         validateRoute(opts.in, opts.availability);
         return await this.routes.insertOneRoute({
             in: opts.in,
         });
     }
+    async replaceRoute(opts) {
+        await this.routes.replaceOneRoute(opts);
+        return await this.findRoute(opts.id);
+    }
+    async createTag(opts) {
+        const out = await this.routes.insertOneTag(opts);
+        const id = requiredOperationID(out, msgCreatedTagIDMissing);
+        return await this.findTag(id);
+    }
+    async replaceTag(opts) {
+        await this.routes.replaceOneTag(opts);
+        return await this.findTag(opts.id);
+    }
+    async searchTags(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.routes.searchManyTags(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async createClientAvailability(opts) {
+        const out = await this.routes.insertOneClientAvailability(opts);
+        const id = requiredOperationID(out, msgCreatedClientAvailabilityIDMissing);
+        return await this.findClientAvailability(id);
+    }
+    async replaceClientAvailability(opts) {
+        await this.routes.replaceOneClientAvailability(opts);
+        return await this.findClientAvailability(opts.id);
+    }
+    async createTracking(opts) {
+        const out = await this.routes.insertOneTracking(opts);
+        const id = requiredOperationID(out, msgCreatedTrackingIDMissing);
+        return await this.findTracking(id);
+    }
+    async replaceTracking(opts) {
+        await this.routes.replaceOneTracking(opts);
+        return await this.findTracking(opts.id);
+    }
+    async createRouteTeam(opts) {
+        const out = await this.routes.insertOneRouteTeam(opts);
+        const id = requiredOperationID(out, msgCreatedRouteTeamIDMissing);
+        return await this.findRouteTeam(id);
+    }
+    async replaceRouteTeam(opts) {
+        await this.routes.replaceOneRouteTeam(opts);
+        return await this.findRouteTeam(opts.id);
+    }
+    async searchRouteTeams(opts) {
+        return await runSearch({
+            search: (searchOpts) => this.routes.searchManyRouteTeams(searchOpts),
+            query: {
+                [OwnerIDKey]: opts.owner_id,
+            },
+            q: opts.q,
+            page: opts.page,
+            per_page: opts.per_page,
+        });
+    }
+    async findRoute(id) {
+        const out = await this.routes.findOneRoute({
+            id,
+        });
+        const route = out.value;
+        if (route === undefined) {
+            throw errResolveFailed({
+                resource: resourceRoute,
+                msg: msgRouteMissing,
+            });
+        }
+        return route;
+    }
+    async findTag(id) {
+        const out = await this.routes.findOneTag({
+            id,
+        });
+        const tag = out.value;
+        if (tag === undefined) {
+            throw errResolveFailed({
+                resource: resourceTag,
+                msg: msgTagMissing,
+            });
+        }
+        return tag;
+    }
+    async findClientAvailability(id) {
+        const out = await this.routes.findOneClientAvailability({
+            id,
+        });
+        const client_availability = out.value;
+        if (client_availability === undefined) {
+            throw errResolveFailed({
+                resource: resourceClientAvailability,
+                msg: msgClientAvailabilityMissing,
+            });
+        }
+        return client_availability;
+    }
+    async findTracking(id) {
+        const out = await this.routes.findOneTracking({
+            id,
+        });
+        const tracking = out.value;
+        if (tracking === undefined) {
+            throw errResolveFailed({
+                resource: resourceTracking,
+                msg: msgTrackingMissing,
+            });
+        }
+        return tracking;
+    }
+    async findRouteTeam(id) {
+        const out = await this.routes.findOneRouteTeam({
+            id,
+        });
+        const route_team = out.value;
+        if (route_team === undefined) {
+            throw errResolveFailed({
+                resource: resourceRouteTeam,
+                msg: msgRouteTeamMissing,
+            });
+        }
+        return route_team;
+    }
 }
 export function newRoutesFX(opts) {
     return new RoutesFX(opts);

package/dist/src/timesheets/timesheets.d.ts

@@ -1,6 +1,10 @@
-import { type Date as SchemaDate, type OperationResult, type WeekSheet } from "@fabriktor/schema";
+import { type Date as SchemaDate, type OperationResult, type Summary, type WeekSheet } from "@fabriktor/schema";
 import type { TimesheetsOperator } from "@fabriktor/client";
 type PunchPayload = Parameters<TimesheetsOperator["punch"]>[0];
+type WeekSheetReplaceOptions = Parameters<TimesheetsOperator["replaceOneWeekSheet"]>[0];
+type SummaryReplaceOptions = Parameters<TimesheetsOperator["replaceOneSummary"]>[0];
+export type ReplaceWeekSheetOptions = WeekSheetReplaceOptions;
+export type ReplaceSummaryOptions = SummaryReplaceOptions;
 export type TimesheetsFXOptions = {
     timesheets: TimesheetsOperator;
 };
@@ -57,6 +61,8 @@ export type ApproveWeekSheetsOptions = {
     week_sheets: WeekSheet[];
 };
 export interface TimesheetsFXOperator {
+    replaceWeekSheet(opts: ReplaceWeekSheetOptions): Promise<WeekSheet>;
+    replaceSummary(opts: ReplaceSummaryOptions): Promise<Summary>;
     punchControls(opts: PunchControlsOptions): PunchControls;
     punchIn(opts: PunchInOptions): Promise<OperationResult>;
     punchOut(opts: PunchOutOptions): Promise<OperationResult>;
@@ -73,6 +79,8 @@ export declare class TimesheetsFX implements TimesheetsFXOperator {
     private timesheets;
     private punch_in_progress;
     constructor(opts: TimesheetsFXOptions);
+    replaceWeekSheet(opts: ReplaceWeekSheetOptions): Promise<WeekSheet>;
+    replaceSummary(opts: ReplaceSummaryOptions): Promise<Summary>;
     punchControls(opts: PunchControlsOptions): PunchControls;
     punchIn(opts: PunchInOptions): Promise<OperationResult>;
     punchOut(opts: PunchOutOptions): Promise<OperationResult>;
@@ -84,6 +92,8 @@ export declare class TimesheetsFX implements TimesheetsFXOperator {
     syncWeek(opts: SyncWeekOptions): Promise<void>;
     syncDays(opts: SyncDaysOptions): Promise<void>;
     approveWeekSheets(opts: ApproveWeekSheetsOptions): Promise<void>;
+    private findWeekSheet;
+    private findSummary;
     private syncSheets;
     private runPunch;
 }