@overmap-ai/core 1.0.57-fix-agent-responses.0 → 1.0.57-fix-agent-responses.2

package/dist/sdk/sdk.d.ts

@@ -1,4 +1,4 @@
-import { AgentService, AuthService, CategoryService, ComponentAttachmentService, ComponentService, ComponentStageCompletionService, ComponentStageService, ComponentTypeAttachmentService, ComponentTypeService, DocumentAttachmentService, DocumentService, EmailDomainsService, EmailVerificationService, FileService, IssueAttachmentService, IssueCommentService, IssueService, IssueTypeService, IssueUpdateService, LicenseService, MainService, OrganizationAccessService, OrganizationService, ProjectAccessService, ProjectAttachmentService, ProjectFileService, ProjectService, TeamService, UserFormService, UserFormSubmissionService, WorkspaceService } from "./services";
+import { AgentService, AuthService, CategoryService, AssetService, AssetStageCompletionService, AssetStageService, AssetAttachmentService, AssetTypeService, AssetTypeAttachmentService, DocumentAttachmentService, DocumentService, EmailDomainsService, EmailVerificationService, FileService, IssueAttachmentService, IssueCommentService, IssueService, IssueTypeService, IssueUpdateService, LicenseService, MainService, OrganizationAccessService, OrganizationService, ProjectAccessService, ProjectAttachmentService, ProjectFileService, ProjectService, TeamService, UserFormService, UserFormSubmissionService, WorkspaceService } from "./services";
 import { ToolkitStore } from "@reduxjs/toolkit/dist/configureStore";
 import { RootState } from "../typings";
 import { SDKRequest } from "./typings";
@@ -31,12 +31,12 @@ export declare class OvermapSDK {
     issueAttachments: IssueAttachmentService;
     workspaces: WorkspaceService;
     main: MainService;
-    components: ComponentService;
-    componentAttachments: ComponentAttachmentService;
-    componentTypes: ComponentTypeService;
-    componentTypeAttachments: ComponentTypeAttachmentService;
-    componentStages: ComponentStageService;
-    componentStageCompletions: ComponentStageCompletionService;
+    assets: AssetService;
+    assetAttachments: AssetAttachmentService;
+    assetTypes: AssetTypeService;
+    assetTypeAttachments: AssetTypeAttachmentService;
+    assetStages: AssetStageService;
+    assetStageCompletions: AssetStageCompletionService;
     userForms: UserFormService;
     userFormSubmissions: UserFormSubmissionService;
     projects: ProjectService;

package/dist/sdk/services/AssetAttachmentService.d.ts

@@ -0,0 +1,10 @@
+import { BaseAttachmentService } from "./BaseAttachmentService";
+import { AttachmentModel, AssetAttachment } from "../../typings";
+import { OptimisticMultipleModelResult } from "../typings";
+export declare class AssetAttachmentService extends BaseAttachmentService {
+    attachmentModel: AttachmentModel;
+    private buildOfflineAttachment;
+    attachFilesToAsset(files: File[], assetId: string): Promise<OptimisticMultipleModelResult<AssetAttachment>>;
+    deleteAssetAttachment(attachmentId: string): Promise<void>;
+    refreshStore(): Promise<void>;
+}

package/dist/sdk/services/AssetService.d.ts

@@ -0,0 +1,11 @@
+import { BaseApiService } from "./BaseApiService";
+import { Asset, Payload } from "../../typings";
+import { OptimisticModelResult } from "../typings";
+export declare class AssetService extends BaseApiService {
+    add(asset: Payload<Asset>, workspaceId: string): OptimisticModelResult<Asset>;
+    update(asset: Asset, workspaceId: string): OptimisticModelResult<Asset>;
+    remove(assetId: string): Promise<undefined>;
+    deleteAllAssetsOfAssetType(assetTypeId: string): Promise<undefined>;
+    addBatch(assetsToCreate: Payload<Asset>[], workspaceId: string, assetTypeId: string): Promise<Record<string, Asset>>;
+    refreshStore(): Promise<void>;
+}

package/dist/sdk/services/AssetStageCompletionService.d.ts

@@ -0,0 +1,16 @@
+import { BaseApiService } from "./BaseApiService";
+import { OptimisticModelResult } from "../typings";
+import { AssetStageCompletion, Payload } from "../../typings";
+export declare class AssetStageCompletionService extends BaseApiService {
+    add(assetId: string, stageId: string): OptimisticModelResult<AssetStageCompletion>;
+    refreshStore(): Promise<void>;
+    /**
+     * Creates a collection of AssetStageCompletions, marking the referenced stages as completed for the referenced
+     * assets. It's REQUIRED that all assets referenced all have the SAME asset type.
+     * @param assetTypeId The ID of the asset type for which we are completing stages (we can only complete
+     * stages for one asset type at a time)
+     * @param stageCompletions
+     */
+    bulkAdd(assetTypeId: string, stageCompletions: Payload<AssetStageCompletion>[]): Promise<void>;
+    bulkDelete(stageId: string, assetIds: string[]): Promise<undefined>;
+}

package/dist/sdk/services/AssetStageService.d.ts

@@ -0,0 +1,11 @@
+import { BaseApiService } from "./BaseApiService";
+import { AssetStage, AssetStagePayload, Payload } from "../../typings";
+export declare class AssetStageService extends BaseApiService {
+    bulkCreateStages(stagesToSubmit: Payload<AssetStagePayload>[], assetTypeId: string, workspaceId: string): Promise<AssetStage[]>;
+    bulkUpdateStages(stagesToUpdate: AssetStage[], assetTypeId: string): Promise<AssetStage[]>;
+    bulkDelete(idsToDelete: string[]): Promise<undefined>;
+    update(assetStage: AssetStage): Promise<undefined>;
+    linkForm(stageId: string, formId: string): Promise<undefined>;
+    unlinkForm(stageId: string, formId: string): Promise<undefined>;
+    refreshStore(): Promise<undefined>;
+}

package/dist/sdk/services/AssetTypeAttachmentService.d.ts

@@ -0,0 +1,10 @@
+import { BaseAttachmentService } from "./BaseAttachmentService";
+import { AttachmentModel, AssetTypeAttachment } from "../../typings";
+import { OptimisticMultipleModelResult } from "../typings";
+export declare class AssetTypeAttachmentService extends BaseAttachmentService {
+    attachmentModel: AttachmentModel;
+    private buildOfflineAttachment;
+    attachFilesToAssetType(files: File[], assetTypeId: string): Promise<OptimisticMultipleModelResult<AssetTypeAttachment>>;
+    deleteAssetTypeAttachment(attachmentId: string): Promise<void>;
+    refreshStore(): Promise<void>;
+}

package/dist/sdk/services/AssetTypeService.d.ts

@@ -0,0 +1,9 @@
+import { BaseApiService } from "./BaseApiService";
+import { AssetType, Payload } from "../../typings";
+import { OptimisticModelResult } from "../typings";
+export declare class AssetTypeService extends BaseApiService {
+    add(assetType: Payload<AssetType>): OptimisticModelResult<AssetType>;
+    update(assetType: AssetType): Promise<undefined>;
+    delete(assetTypeId: string): Promise<undefined>;
+    refreshStore(): Promise<void>;
+}

package/dist/sdk/services/UserFormService.d.ts

@@ -5,12 +5,12 @@ export declare class UserFormService extends BaseApiService {
     private getAttachImagePromises;
     private add;
     addForOrganization(initialRevision: UserFormRevisionPayload, attachedTo?: {
-        componentTypeId: string;
+        assetTypeId: string;
     } | {
         issueTypeId: string;
     }): Promise<[SubmittedUserForm, UserFormRevision, Promise<UserFormRevision>, Promise<UserFormRevision>]>;
     addForCurrentUser(initialRevision: UserFormRevision, attachedTo?: {
-        componentTypeId: string;
+        assetTypeId: string;
     } | {
         issueTypeId: string;
     }): Promise<[SubmittedUserForm, UserFormRevision, Promise<UserFormRevision>, Promise<UserFormRevision>]>;

package/dist/sdk/services/UserFormSubmissionService.d.ts

@@ -10,7 +10,7 @@ export declare class UserFormSubmissionService extends BaseApiService {
     bulkAdd(args: {
         formRevision: string;
         values: Record<string, FieldValue>;
-        componentOfflineIds: string[];
+        assetOfflineIds: string[];
     }): Promise<OptimisticMultipleModelResult<UserFormSubmission>>;
     update(submission: Stored<UserFormSubmission>): OptimisticModelResult<UserFormSubmission>;
     delete(submissionId: string): Promise<undefined>;

package/dist/sdk/services/index.d.ts

@@ -1,12 +1,12 @@
 export * from "./AuthService";
 export * from "./BaseApiService";
 export * from "./CategoryService";
-export * from "./ComponentService";
-export * from "./ComponentStageCompletionService";
-export * from "./ComponentStageService";
-export * from "./ComponentAttachmentService";
-export * from "./ComponentTypeService";
-export * from "./ComponentTypeAttachmentService";
+export * from "./AssetService";
+export * from "./AssetStageCompletionService";
+export * from "./AssetStageService";
+export * from "./AssetAttachmentService";
+export * from "./AssetTypeService";
+export * from "./AssetTypeAttachmentService";
 export * from "./IssueCommentService";
 export * from "./IssueUpdateService";
 export * from "./IssueAttachmentService";

package/dist/store/slices/assetSlice.d.ts

@@ -0,0 +1,63 @@
+import { PayloadAction, Reducer } from "@reduxjs/toolkit";
+import { Asset, AssetAttachment, AssetType, RootState, Selector, SelectorWithArgs, Stored, Submitted } from "../../typings";
+export interface AssetState {
+    assets: Record<string, Asset | Submitted<Asset>>;
+    attachments: Record<string, Stored<AssetAttachment>>;
+}
+export declare const assetSlice: import("@reduxjs/toolkit").Slice<AssetState, {
+    addAsset: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<Asset>) => void;
+    addAssetsInBatches: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<(Asset | Submitted<Asset>)[]>) => void;
+    setAssets: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<Asset[]>) => void;
+    updateAsset: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<Asset>) => void;
+    removeAsset: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<string>) => void;
+    removeAllAssetsOfType: (state: import("immer/dist/internal.js").WritableDraft<AssetState>, action: PayloadAction<string>) => void;
+    setAssetAttachment: (state: AssetState, action: {
+        payload: Stored<AssetAttachment>;
+        type: string;
+    }) => void;
+    setAssetAttachments: (state: AssetState, action: {
+        payload: Stored<AssetAttachment>[];
+        type: string;
+    }) => void;
+    addAssetAttachment: (state: AssetState, action: {
+        payload: Submitted<AssetAttachment>;
+        type: string;
+    }) => void;
+    addAssetAttachments: (state: AssetState, action: {
+        payload: Submitted<AssetAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetAttachment: (state: AssetState, action: {
+        payload: Submitted<AssetAttachment>;
+        type: string;
+    }) => void;
+    updateAssetAttachments: (state: AssetState, action: {
+        payload: Submitted<AssetAttachment>[];
+        type: string;
+    }) => void;
+    removeAssetAttachment: (state: AssetState, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    removeAssetAttachments: (state: AssetState, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assets">;
+export declare const addAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset, "assets/addAsset">, updateAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset, "assets/updateAsset">, removeAsset: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assets/removeAsset">, addAssetsInBatches: import("@reduxjs/toolkit").ActionCreatorWithPayload<(Asset | Submitted<Asset>)[], "assets/addAssetsInBatches">, setAssets: import("@reduxjs/toolkit").ActionCreatorWithPayload<Asset[], "assets/setAssets">, removeAllAssetsOfType: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assets/removeAllAssetsOfType">, setAssetAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>, "assets/setAssetAttachment">, setAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetAttachment>[], "assets/setAssetAttachments">, addAssetAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<AssetAttachment>, "assets/addAssetAttachment">, addAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<AssetAttachment>[], "assets/addAssetAttachments">, updateAssetAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<AssetAttachment>, "assets/updateAssetAttachment">, updateAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<AssetAttachment>[], "assets/updateAssetAttachments">, removeAssetAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assets/removeAssetAttachment">, removeAssetAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assets/removeAssetAttachments">;
+export declare const selectAssets: (state: RootState) => Asset[];
+export declare const selectAssetsMapping: (state: RootState) => Record<string, Asset | Submitted<Asset>>;
+export declare const selectAssetsOfAssetType: SelectorWithArgs<string, Asset[]>;
+export declare const selectAsset: SelectorWithArgs<string, Asset>;
+export declare const selectAssetToAssetTypeMapping: Selector<Record<string, AssetType>>;
+export declare const selectNumberOfAssetsOfAssetType: SelectorWithArgs<string | undefined, number>;
+export declare const selectAssetTypesFromIds: SelectorWithArgs<string[], AssetType[]>;
+export declare const selectAssetAttachmentMapping: (state: RootState) => Record<string, Stored<AssetAttachment>>;
+export declare const selectAssetAttachments: Selector<Stored<AssetAttachment>[]>;
+export declare const selectAssetAttachment: SelectorWithArgs<string, Stored<AssetAttachment>>;
+export declare const selectAttachmentsOfAsset: (args: string) => (state: RootState) => Stored<AssetAttachment>[];
+export declare const selectAttachmentsOfAssetByType: (args: string) => (state: RootState) => {
+    fileAttachments: Stored<AssetAttachment>[];
+    imageAttachments: Stored<AssetAttachment>[];
+};
+export declare const assetReducer: Reducer<AssetState>;

package/dist/store/slices/assetStageCompletionSlice.d.ts

@@ -0,0 +1,15 @@
+import { Reducer, PayloadAction } from "@reduxjs/toolkit";
+import { CompletedStagesMapping, Asset, RootState, SelectorWithArgs, AssetStageCompletion } from "../../typings";
+export interface AssetStageCompletionState {
+    completionsByAssetId: CompletedStagesMapping;
+}
+export declare const assetStageCompletionSlice: import("@reduxjs/toolkit").Slice<AssetStageCompletionState, {
+    addStageCompletion: (state: import("immer/dist/internal.js").WritableDraft<AssetStageCompletionState>, action: PayloadAction<AssetStageCompletion>) => void;
+    addStageCompletions: (state: import("immer/dist/internal.js").WritableDraft<AssetStageCompletionState>, action: PayloadAction<CompletedStagesMapping>) => void;
+    removeStageCompletions: (state: import("immer/dist/internal.js").WritableDraft<AssetStageCompletionState>, action: PayloadAction<AssetStageCompletion[]>) => void;
+    setStageCompletions: (state: import("immer/dist/internal.js").WritableDraft<AssetStageCompletionState>, action: PayloadAction<CompletedStagesMapping>) => void;
+}, "assetStageCompletions">;
+export declare const addStageCompletion: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStageCompletion, "assetStageCompletions/addStageCompletion">, addStageCompletions: import("@reduxjs/toolkit").ActionCreatorWithPayload<CompletedStagesMapping, "assetStageCompletions/addStageCompletions">, removeStageCompletions: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStageCompletion[], "assetStageCompletions/removeStageCompletions">, setStageCompletions: import("@reduxjs/toolkit").ActionCreatorWithPayload<CompletedStagesMapping, "assetStageCompletions/setStageCompletions">;
+export declare const selectCompletedStages: (state: RootState) => CompletedStagesMapping;
+export declare const selectCompletedStageIdsForAsset: SelectorWithArgs<Asset, string[]>;
+export declare const assetStageCompletionReducer: Reducer<AssetStageCompletionState>;

package/dist/store/slices/assetStageSlice.d.ts

@@ -0,0 +1,32 @@
+import { Reducer, PayloadAction } from "@reduxjs/toolkit";
+import { AssetStage, RootState, SelectorWithArgs } from "../../typings";
+export interface AssetStageState {
+    stages: Record<string, AssetStage>;
+}
+export declare const assetStageSlice: import("@reduxjs/toolkit").Slice<AssetStageState, {
+    addStages: (state: import("immer/dist/internal.js").WritableDraft<AssetStageState>, action: PayloadAction<AssetStage[]>) => void;
+    updateStages: (state: import("immer/dist/internal.js").WritableDraft<AssetStageState>, action: PayloadAction<AssetStage[]>) => void;
+    removeStages: (state: import("immer/dist/internal.js").WritableDraft<AssetStageState>, action: PayloadAction<string[]>) => void;
+    linkStageToForm: (state: import("immer/dist/internal.js").WritableDraft<AssetStageState>, action: PayloadAction<{
+        stageId: string;
+        formId: string;
+    }>) => void;
+    unlinkStageToForm: (state: import("immer/dist/internal.js").WritableDraft<AssetStageState>, action: PayloadAction<{
+        stageId: string;
+    }>) => void;
+}, "assetStages">;
+export declare const selectStageMapping: (state: RootState) => Record<string, AssetStage>;
+export declare const selectStage: SelectorWithArgs<string, AssetStage | undefined>;
+export declare const selectStages: (state: RootState) => AssetStage[];
+export declare const selectStagesFromAssetTypeIds: SelectorWithArgs<string[], Record<string, AssetStage[]>>;
+export declare const selectAssetTypeStagesMapping: SelectorWithArgs<string, Record<string, AssetStage>>;
+export declare const selectStagesOfAssetType: SelectorWithArgs<string, AssetStage[]>;
+export declare const selectStagesFromStageIds: SelectorWithArgs<string[], AssetStage[]>;
+export declare const selectStageFormIdsFromStageIds: SelectorWithArgs<string[], Record<string, string>>;
+export declare const addStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStage[], "assetStages/addStages">, updateStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetStage[], "assetStages/updateStages">, removeStages: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetStages/removeStages">, linkStageToForm: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    stageId: string;
+    formId: string;
+}, "assetStages/linkStageToForm">, unlinkStageToForm: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    stageId: string;
+}, "assetStages/unlinkStageToForm">;
+export declare const assetStageReducer: Reducer<AssetStageState>;

package/dist/store/slices/assetTypeSlice.d.ts

@@ -0,0 +1,74 @@
+import type { Reducer } from "@reduxjs/toolkit";
+import type { AssetType, AssetTypeAttachment, RootState, Selector, SelectorWithArgs, Stored } from "../../typings";
+export interface AssetTypeState {
+    assetTypes: Record<string, AssetType>;
+    hiddenAssetTypeIds: Record<string, boolean>;
+    attachments: Record<string, AssetTypeAttachment>;
+}
+export declare const assetTypeSlice: import("@reduxjs/toolkit").Slice<AssetTypeState, {
+    addAssetType: (state: import("immer/dist/internal.js").WritableDraft<AssetTypeState>, action: {
+        payload: AssetType;
+    }) => void;
+    setAssetTypes: (state: import("immer/dist/internal.js").WritableDraft<AssetTypeState>, action: {
+        payload: AssetType[];
+    }) => void;
+    toggleAssetTypeVisibility: (state: import("immer/dist/internal.js").WritableDraft<AssetTypeState>, action: {
+        payload: string;
+    }) => void;
+    deleteAssetType: (state: import("immer/dist/internal.js").WritableDraft<AssetTypeState>, action: {
+        payload: string;
+    }) => void;
+    setAssetTypeAttachment: (state: AssetTypeState, action: {
+        payload: Stored<AssetTypeAttachment>;
+        type: string;
+    }) => void;
+    setAssetTypeAttachments: (state: AssetTypeState, action: {
+        payload: Stored<AssetTypeAttachment>[];
+        type: string;
+    }) => void;
+    addAssetTypeAttachment: (state: AssetTypeState, action: {
+        payload: import('../../typings/models/issues').Submitted<AssetTypeAttachment>;
+        type: string;
+    }) => void;
+    addAssetTypeAttachments: (state: AssetTypeState, action: {
+        payload: import('../../typings/models/issues').Submitted<AssetTypeAttachment>[];
+        type: string;
+    }) => void;
+    updateAssetTypeAttachment: (state: AssetTypeState, action: {
+        payload: import('../../typings/models/issues').Submitted<AssetTypeAttachment>;
+        type: string;
+    }) => void;
+    updateAssetTypeAttachments: (state: AssetTypeState, action: {
+        payload: import('../../typings/models/issues').Submitted<AssetTypeAttachment>[];
+        type: string;
+    }) => void;
+    removeAssetTypeAttachment: (state: AssetTypeState, action: {
+        payload: string;
+        type: string;
+    }) => void;
+    removeAssetTypeAttachments: (state: AssetTypeState, action: {
+        payload: string[];
+        type: string;
+    }) => void;
+}, "assetTypes">;
+export declare const addAssetType: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetType, "assetTypes/addAssetType">, setAssetTypes: import("@reduxjs/toolkit").ActionCreatorWithPayload<AssetType[], "assetTypes/setAssetTypes">, toggleAssetTypeVisibility: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypes/toggleAssetTypeVisibility">, deleteAssetType: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypes/deleteAssetType">, setAssetTypeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>, "assetTypes/setAssetTypeAttachment">, setAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<AssetTypeAttachment>[], "assetTypes/setAssetTypeAttachments">, addAssetTypeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<import('../../typings/models/issues').Submitted<AssetTypeAttachment>, "assetTypes/addAssetTypeAttachment">, addAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<import('../../typings/models/issues').Submitted<AssetTypeAttachment>[], "assetTypes/addAssetTypeAttachments">, updateAssetTypeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<import('../../typings/models/issues').Submitted<AssetTypeAttachment>, "assetTypes/updateAssetTypeAttachment">, updateAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<import('../../typings/models/issues').Submitted<AssetTypeAttachment>[], "assetTypes/updateAssetTypeAttachments">, removeAssetTypeAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "assetTypes/removeAssetTypeAttachment">, removeAssetTypeAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "assetTypes/removeAssetTypeAttachments">;
+export declare const selectAssetTypesMapping: Selector<Record<string, AssetType>>;
+export declare const selectAssetTypes: Selector<AssetType[]>;
+export declare const selectAssetType: SelectorWithArgs<string, AssetType>;
+interface selectNumberOfAssetTypesMatchingCaseInsensitiveNameProps {
+    name: string | null | undefined;
+    assetTypeId: string | undefined;
+}
+export declare const selectNumberOfAssetTypesMatchingCaseInsensitiveName: SelectorWithArgs<selectNumberOfAssetTypesMatchingCaseInsensitiveNameProps, number>;
+export declare const selectAssetTypesByName: SelectorWithArgs<string, AssetType[]>;
+export declare const selectHiddenAssetTypeIds: Selector<Record<string, boolean | undefined>>;
+export declare const selectAssetTypeAttachmentMapping: (state: RootState) => Record<string, AssetTypeAttachment>;
+export declare const selectAssetTypeAttachments: Selector<Stored<AssetTypeAttachment>[]>;
+export declare const selectAssetTypeAttachment: SelectorWithArgs<string, Stored<AssetTypeAttachment>>;
+export declare const selectAttachmentsOfAssetType: (args: string) => (state: RootState) => Stored<AssetTypeAttachment>[];
+export declare const selectAttachmentsOfAssetTypeByType: (args: string) => (state: RootState) => {
+    fileAttachments: Stored<AssetTypeAttachment>[];
+    imageAttachments: Stored<AssetTypeAttachment>[];
+};
+export declare const assetTypeReducer: Reducer<AssetTypeState>;
+export {};

package/dist/store/slices/categorySlice.d.ts

@@ -46,10 +46,10 @@ export declare const selectCategories: ((state: import("redux").EmptyObject & {
     fileReducer: import('..').FileState;
     authReducer: import('..').AuthState;
     categoryReducer: CategoryState;
-    componentReducer: import('..').ComponentState;
-    componentStageCompletionReducer: import('..').ComponentStageCompletionState;
-    componentStageReducer: import('..').ComponentStageState;
-    componentTypeReducer: import('..').ComponentTypeState;
+    assetReducer: import('..').AssetState;
+    assetStageCompletionReducer: import('..').AssetStageCompletionState;
+    assetStageReducer: import('..').AssetStageState;
+    assetTypeReducer: import('..').AssetTypeState;
     issueReducer: import('..').IssueState;
     issueTypeReducer: import('..').IssueTypeState;
     mapReducer: import('..').MapState;

package/dist/store/slices/documentSlice.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="@redux-offline/redux-offline" />
 import { Reducer } from "@reduxjs/toolkit";
 import { DocumentAttachment, MovePosition, Document, RootState, Selector, SelectorWithArgs, Stored, Submitted } from "../../typings";
-import { AppSelector } from "./componentTypeSlice";
 export interface DocumentState {
     documents: Record<string, Stored<Document>>;
     attachments: Record<string, Stored<DocumentAttachment>>;
@@ -193,8 +192,8 @@ export declare const setDocuments: import("@reduxjs/toolkit").ActionCreatorWithP
 } & {
     children_documents: string[];
 }, "id" | "created_at" | "created_by">)>>[], "documents/updateDocuments">, moveDocument: import("@reduxjs/toolkit").ActionCreatorWithPayload<MoveDocumentPayload, "documents/moveDocument">, removeDocuments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "documents/removeDocuments">, setDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>, "documents/setDocumentAttachment">, setDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Stored<DocumentAttachment>[], "documents/setDocumentAttachments">, addDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<DocumentAttachment>, "documents/addDocumentAttachment">, addDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<DocumentAttachment>[], "documents/addDocumentAttachments">, updateDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<DocumentAttachment>, "documents/updateDocumentAttachment">, updateDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<Submitted<DocumentAttachment>[], "documents/updateDocumentAttachments">, removeDocumentAttachment: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "documents/removeDocumentAttachment">, removeDocumentAttachments: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "documents/removeDocumentAttachments">;
-export declare const selectDocumentsMapping: AppSelector<Record<string, Stored<Document>>>;
-export declare const selectDocuments: AppSelector<Stored<Document>[]>;
+export declare const selectDocumentsMapping: Selector<Record<string, Stored<Document>>>;
+export declare const selectDocuments: Selector<Stored<Document>[]>;
 export declare const selectDocument: (args: string) => (state: RootState) => (import('../../typings/models/base').OfflineModel & import('../../typings/models/base').CreatedByModel & {
     title: string | null;
     description: string | null;
@@ -246,10 +245,10 @@ export declare const selectRootDocuments: ((state: import("redux").EmptyObject &
     fileReducer: import('..').FileState;
     authReducer: import('..').AuthState;
     categoryReducer: import('..').CategoryState;
-    componentReducer: import('..').ComponentState;
-    componentStageCompletionReducer: import('..').ComponentStageCompletionState;
-    componentStageReducer: import('..').ComponentStageState;
-    componentTypeReducer: import("./componentTypeSlice").ComponentTypeState;
+    assetReducer: import('..').AssetState;
+    assetStageCompletionReducer: import('..').AssetStageCompletionState;
+    assetStageReducer: import('..').AssetStageState;
+    assetTypeReducer: import('..').AssetTypeState;
     issueReducer: import('..').IssueState;
     issueTypeReducer: import('..').IssueTypeState;
     mapReducer: import('..').MapState;

package/dist/store/slices/formRevisionSlice.d.ts

@@ -25,10 +25,10 @@ export declare const selectFormRevisions: ((state: import("redux").EmptyObject &
     fileReducer: import('..').FileState;
     authReducer: import('..').AuthState;
     categoryReducer: import('..').CategoryState;
-    componentReducer: import('..').ComponentState;
-    componentStageCompletionReducer: import('..').ComponentStageCompletionState;
-    componentStageReducer: import('..').ComponentStageState;
-    componentTypeReducer: import('..').ComponentTypeState;
+    assetReducer: import('..').AssetState;
+    assetStageCompletionReducer: import('..').AssetStageCompletionState;
+    assetStageReducer: import('..').AssetStageState;
+    assetTypeReducer: import('..').AssetTypeState;
     issueReducer: import('..').IssueState;
     issueTypeReducer: import('..').IssueTypeState;
     mapReducer: import('..').MapState;
@@ -61,7 +61,7 @@ export declare const selectFormRevision: SelectorWithArgs<string, Stored<UserFor
 export declare const _selectLatestFormRevision: (formRevisions: FormRevisionState["formRevisions"], formId: string) => Stored<UserFormRevision>;
 export declare const selectLatestFormRevisionOfForm: SelectorWithArgs<string, Stored<UserFormRevision>>;
 export declare const selectFormRevisionsOfForm: SelectorWithArgs<string, Stored<UserFormRevision>[]>;
-export declare const selectLatestFormRevisionsOfComponentTypes: SelectorWithArgs<string[], Record<string, Stored<UserFormRevision>>>;
+export declare const selectLatestFormRevisionsOfAssetTypes: SelectorWithArgs<string[], Record<string, Stored<UserFormRevision>>>;
 export declare const selectLatestFormRevisionByForm: Selector<Record<Stored<UserForm>["offline_id"], Stored<UserFormRevision>>>;
 export declare const selectUserFormRevisionAttachmentsMapping: Selector<FormRevisionState["attachments"]>;
 export declare const selectAttachmentsOfFormRevision: SelectorWithArgs<string, Stored<UserFormRevisionAttachment>[]>;

package/dist/store/slices/formSlice.d.ts

@@ -24,7 +24,7 @@ export declare const formSlice: import("@reduxjs/toolkit").Slice<FormState, {
 }, "forms">;
 export declare const setForms: import("@reduxjs/toolkit").ActionCreatorWithPayload<((Pick<import('../../typings/models/workspace').WorkspaceIndexedModel, "index_workspace"> & {
     favorite: boolean;
-    component_type?: string | undefined;
+    asset_type?: string | undefined;
     issue_type?: string | undefined;
 } & {
     owner_organization: number;
@@ -36,7 +36,7 @@ export declare const setForms: import("@reduxjs/toolkit").ActionCreatorWithPaylo
     submitted_at: string;
 }) | (Pick<import('../../typings/models/workspace').WorkspaceIndexedModel, "index_workspace"> & {
     favorite: boolean;
-    component_type?: string | undefined;
+    asset_type?: string | undefined;
     issue_type?: string | undefined;
 } & {
     owner_organization: undefined;
@@ -48,7 +48,7 @@ export declare const setForms: import("@reduxjs/toolkit").ActionCreatorWithPaylo
     submitted_at: string;
 }))[], "forms/setForms">, addForm: import("@reduxjs/toolkit").ActionCreatorWithPayload<(Pick<import('../../typings/models/workspace').WorkspaceIndexedModel, "index_workspace"> & {
     favorite: boolean;
-    component_type?: string | undefined;
+    asset_type?: string | undefined;
     issue_type?: string | undefined;
 } & {
     owner_organization: number;
@@ -60,7 +60,7 @@ export declare const setForms: import("@reduxjs/toolkit").ActionCreatorWithPaylo
     submitted_at: string;
 }) | (Pick<import('../../typings/models/workspace').WorkspaceIndexedModel, "index_workspace"> & {
     favorite: boolean;
-    component_type?: string | undefined;
+    asset_type?: string | undefined;
     issue_type?: string | undefined;
 } & {
     owner_organization: undefined;
@@ -72,7 +72,7 @@ export declare const setForms: import("@reduxjs/toolkit").ActionCreatorWithPaylo
     submitted_at: string;
 }), "forms/addForm">, addForms: import("@reduxjs/toolkit").ActionCreatorWithPayload<((Pick<import('../../typings/models/workspace').WorkspaceIndexedModel, "index_workspace"> & {
     favorite: boolean;
-    component_type?: string | undefined;
+    asset_type?: string | undefined;
     issue_type?: string | undefined;
 } & {
     owner_organization: number;
@@ -84,7 +84,7 @@ export declare const setForms: import("@reduxjs/toolkit").ActionCreatorWithPaylo
     submitted_at: string;
 }) | (Pick<import('../../typings/models/workspace').WorkspaceIndexedModel, "index_workspace"> & {
     favorite: boolean;
-    component_type?: string | undefined;
+    asset_type?: string | undefined;
     issue_type?: string | undefined;
 } & {
     owner_organization: undefined;
@@ -110,7 +110,7 @@ export type FormSearchArgs = SearchArgs<{
 export declare const selectFilteredForms: SelectorWithArgs<FormSearchArgs, CachedUserForm[]>;
 export declare const selectForm: SelectorWithArgs<string, Stored<UserForm>>;
 export declare const selectFormMapping: Selector<Record<Stored<UserForm>["offline_id"], Stored<UserForm>>>;
-export declare const selectFormOfComponentType: SelectorWithArgs<string, Stored<UserForm>>;
+export declare const selectFormOfAssetType: SelectorWithArgs<string, Stored<UserForm>>;
 export declare const selectFormOfIssueType: SelectorWithArgs<string, Stored<UserForm>>;
 export declare const selectFormsCount: Selector<number>;
 export declare const selectGeneralFormCount: Selector<number>;

package/dist/store/slices/formSubmissionSlice.d.ts

@@ -42,8 +42,8 @@ export declare const selectFormSubmissionsOfForm: SelectorWithArgs<string, Store
 export declare const selectFormSubmissionsByFormRevisions: Selector<Record<string, Stored<UserFormSubmission>[]>>;
 export declare const selectSortedFormSubmissionsOfForm: SelectorWithArgs<string, Stored<UserFormSubmission>[]>;
 export declare const selectFormSubmissionsOfIssue: SelectorWithArgs<string, Stored<UserFormSubmission>[]>;
-export declare const selectFormSubmissionsOfComponent: SelectorWithArgs<string, Stored<UserFormSubmission>[]>;
-export declare const selectFormSubmissionsByComponents: Selector<Record<string, Stored<UserFormSubmission>[]>>;
+export declare const selectFormSubmissionsOfAsset: SelectorWithArgs<string, Stored<UserFormSubmission>[]>;
+export declare const selectFormSubmissionsByAssets: Selector<Record<string, Stored<UserFormSubmission>[]>>;
 export declare const selectFormSubmissionAttachmentsMapping: Selector<FormSubmissionState["attachments"]>;
 export declare const selectAttachmentsOfFormSubmission: SelectorWithArgs<string, Stored<UserFormSubmissionAttachment>[]>;
 export declare const formSubmissionReducer: Reducer<FormSubmissionState>;

package/dist/store/slices/index.d.ts

@@ -1,9 +1,9 @@
 export * from "./authSlice";
 export * from "./categorySlice";
-export * from "./componentSlice";
-export * from "./ComponentStageCompletionSlice";
-export * from "./componentStageSlice";
-export * from "./componentTypeSlice";
+export * from "./assetSlice";
+export * from "./assetStageCompletionSlice";
+export * from "./assetStageSlice";
+export * from "./assetTypeSlice";
 export * from "./issueSlice";
 export * from "./issueTypeSlice";
 export * from "./fileSlice";

package/dist/store/slices/issueSlice.d.ts

@@ -134,10 +134,10 @@ export declare const selectAllAttachments: ((state: import("redux").EmptyObject
     fileReducer: import('..').FileState;
     authReducer: import('..').AuthState;
     categoryReducer: import("./categorySlice").CategoryState;
-    componentReducer: import('..').ComponentState;
-    componentStageCompletionReducer: import('..').ComponentStageCompletionState;
-    componentStageReducer: import('..').ComponentStageState;
-    componentTypeReducer: import('..').ComponentTypeState;
+    assetReducer: import('..').AssetState;
+    assetStageCompletionReducer: import('..').AssetStageCompletionState;
+    assetStageReducer: import('..').AssetStageState;
+    assetTypeReducer: import('..').AssetTypeState;
     issueReducer: IssueState;
     issueTypeReducer: import('..').IssueTypeState;
     mapReducer: import('..').MapState;

package/dist/store/slices/projectFileSlice.d.ts

@@ -54,10 +54,10 @@ export declare const selectProjectFiles: ((state: import("redux").EmptyObject &
     fileReducer: import('..').FileState;
     authReducer: import('..').AuthState;
     categoryReducer: import('..').CategoryState;
-    componentReducer: import('..').ComponentState;
-    componentStageCompletionReducer: import('..').ComponentStageCompletionState;
-    componentStageReducer: import('..').ComponentStageState;
-    componentTypeReducer: import('..').ComponentTypeState;
+    assetReducer: import('..').AssetState;
+    assetStageCompletionReducer: import('..').AssetStageCompletionState;
+    assetStageReducer: import('..').AssetStageState;
+    assetTypeReducer: import('..').AssetTypeState;
     issueReducer: import('..').IssueState;
     issueTypeReducer: import('..').IssueTypeState;
     mapReducer: import('..').MapState;

package/dist/store/slices/workspaceSlice.d.ts

@@ -32,10 +32,10 @@ export declare const selectWorkspaces: ((state: import("redux").EmptyObject & {
     fileReducer: import('..').FileState;
     authReducer: import('..').AuthState;
     categoryReducer: import('..').CategoryState;
-    componentReducer: import('..').ComponentState;
-    componentStageCompletionReducer: import('..').ComponentStageCompletionState;
-    componentStageReducer: import('..').ComponentStageState;
-    componentTypeReducer: import('..').ComponentTypeState;
+    assetReducer: import('..').AssetState;
+    assetStageCompletionReducer: import('..').AssetStageCompletionState;
+    assetStageReducer: import('..').AssetStageState;
+    assetTypeReducer: import('..').AssetTypeState;
     issueReducer: import('..').IssueState;
     issueTypeReducer: import('..').IssueTypeState;
     mapReducer: import('..').MapState;