@overmap-ai/core 2.0.6 → 2.0.7-slice-reducer-name-updates.0

package/dist/store/selectors/formSubmissionFieldValuesSelectors.d.ts

@@ -0,0 +1,8 @@
+import { FormSubmission, FormSubmissionFieldValues, Stored } from '@overmap-ai/common';
+import { FormSubmissionFieldValuesState } from '../slices/formSubmissionFieldValuesSlice';
+import { OvermapSelector, OvermapSelectorWithArgs } from '../typings';
+export declare const selectFormSubmissionFieldValuesMapping: OvermapSelector<FormSubmissionFieldValuesState["instances"]>;
+export declare const selectFormSubmissionFieldValues: OvermapSelector<Stored<FormSubmissionFieldValues>[]>;
+export declare const selectFormSubmissionFieldValuesById: OvermapSelectorWithArgs<FormSubmissionFieldValues["uuid"], Stored<FormSubmissionFieldValues> | undefined>;
+export declare const selectFormSubmissionFieldValuesByIds: (uuids: string[]) => (state: any) => Stored<FormSubmissionFieldValues>[];
+export declare const selectFormSubmissionFieldValuesOfFormSubmission: OvermapSelectorWithArgs<FormSubmission["uuid"], Stored<FormSubmissionFieldValues>[]>;

package/dist/store/selectors/formSubmissionSelectors.d.ts

@@ -0,0 +1,16 @@
+import { Asset, Form, FormSubmission, Issue, Organization, Project, Stored } from '@overmap-ai/common';
+import { FormSubmissionState } from '../slices/formSubmissionSlice';
+import { OvermapSelector, OvermapSelectorWithArgs } from '../typings';
+export declare const selectFormSubmissionsMapping: OvermapSelector<FormSubmissionState["instances"]>;
+export declare const selectFormSubmissions: OvermapSelector<Stored<FormSubmission>[]>;
+export declare const selectFormSubmissionById: OvermapSelectorWithArgs<FormSubmission["uuid"], Stored<FormSubmission> | undefined>;
+export declare const selectFormSubmissionsByIds: (uuids: string[]) => (state: any) => Stored<FormSubmission>[];
+export declare const selectFormSubmissionsOfForm: OvermapSelectorWithArgs<Form["uuid"], Stored<FormSubmission>[]>;
+export declare const selectFormSubmissionsOfOrganization: OvermapSelectorWithArgs<Organization["uuid"], Stored<FormSubmission>[]>;
+export declare const selectFormSubmissionsOfProject: OvermapSelectorWithArgs<Project["uuid"], Stored<FormSubmission>[]>;
+export declare const selectFormSubmissionsOfProjectAndForm: (_projectId: string, formId: string) => (state: any) => Stored<FormSubmission>[];
+export declare const selectFormSubmissionsOfOrganizationAndForm: (_organizationId: string, formId: string) => (state: any) => Stored<FormSubmission>[];
+export declare const selectFormSubmissionsOfIssue: OvermapSelectorWithArgs<Issue["uuid"], Stored<FormSubmission>[]>;
+export declare const selectFormSubmissionsOfIssues: OvermapSelectorWithArgs<Issue["uuid"][], Stored<FormSubmission>[]>;
+export declare const selectFormSubmissionsOfAsset: OvermapSelectorWithArgs<Asset["uuid"], Stored<FormSubmission>[]>;
+export declare const selectFormSubmissionsOfAssets: OvermapSelectorWithArgs<Asset["uuid"][], Stored<FormSubmission>[]>;

package/dist/store/selectors/formSubscriberSelectors.d.ts

@@ -0,0 +1,9 @@
+import { Form, FormSubscriber, Stored, User } from '@overmap-ai/common';
+import { FormSubscriberState } from '../slices/formSubscriberSlice';
+import { OvermapSelector, OvermapSelectorWithArgs } from '../typings';
+export declare const selectFormSubscriberMapping: OvermapSelector<FormSubscriberState["instances"]>;
+export declare const selectFormSubscribers: OvermapSelector<Stored<FormSubscriber>[]>;
+export declare const selectFormSubscriberById: OvermapSelectorWithArgs<FormSubscriber["uuid"], Stored<FormSubscriber> | undefined>;
+export declare const selectFormSubscribersByIds: (uuids: string[]) => (state: any) => Stored<FormSubscriber>[];
+export declare const selectFormSubscribersOfForm: OvermapSelectorWithArgs<Form["uuid"], Stored<FormSubscriber>[]>;
+export declare const selectFormSubscribersOfUser: OvermapSelectorWithArgs<User["id"], Stored<FormSubscriber>[]>;

package/dist/store/selectors/geoImageSelectors.d.ts

@@ -0,0 +1,109 @@
+import { GeoImage, Project, Stored } from '@overmap-ai/common';
+import { OvermapRootState, OvermapSelectorWithArgs } from '../typings';
+export declare const selectGeoImageMapping: (state: OvermapRootState) => Record<string, Stored<GeoImage>>;
+export declare const selectGeoImages: ((state: {
+    readonly assets: import('..').AssetState;
+    readonly assetAttachments: import('..').AssetAttachmentState;
+    readonly assetCommentAttachments: import('..').AssetCommentAttachmentState;
+    readonly assetComments: import('..').AssetCommentState;
+    readonly assetTypes: import('..').AssetTypeState;
+    readonly assetTypeAttachments: import('..').AssetTypeAttachmentState;
+    readonly issues: import('..').IssueState;
+    readonly issueAttachments: import('..').IssueAttachmentState;
+    readonly issueTypes: import('..').IssueTypeState;
+    readonly issueTypeAttachments: import('..').IssueTypeAttachmentState;
+    readonly organizations: import('..').OrganizationState;
+    readonly projects: import('..').ProjectState;
+    readonly projectAttachments: import('..').ProjectAttachmentState;
+    readonly projectComments: import('..').ProjectCommentState;
+    readonly projectAccess: import('..').ProjectAccessState;
+    readonly organizationAccess: import('..').OrganizationAccessState;
+    readonly projectFiles: import('..').ProjectFileState;
+    readonly procedureTypes: import('..').ProcedureTypeState;
+    readonly procedureInitiatives: import('..').ProcedureInitiativeState;
+    readonly procedures: import('..').ProcedureState;
+    readonly procedureTypeFields: import('..').ProcedureTypeFieldsState;
+    readonly procedureFieldValues: import('..').ProcedureFieldValuesState;
+    readonly procedureTypeAttachments: import('..').ProcedureTypeAttachmentState;
+    readonly procedureTypeFieldsAttachments: import('..').ProcedureTypeFieldsAttachmentState;
+    readonly procedureFieldValuesAttachments: import('..').ProcedureFieldValuesAttachmentState;
+    readonly procedureStepFieldsAttachments: import('..').ProcedureStepFieldsAttachmentState;
+    readonly procedureStepFields: import('..').ProcedureStepFieldsState;
+    readonly procedureStepFieldValuesAttachments: import('..').ProcedureStepFieldValuesAttachmentState;
+    readonly procedureStepFieldValues: import('..').ProcedureStepFieldValuesState;
+    readonly procedureStepFieldValuesReviews: import('..').ProcedureStepFieldValuesReviewState;
+    readonly procedureStepAssignees: import('..').ProcedureStepAssigneeState;
+    readonly procedureStepComments: import('..').ProcedureStepCommentState;
+    readonly procedureStepDefaultAssignees: import('..').ProcedureStepDefaultAssigneeState;
+    readonly procedureStepDefaultReviewers: import('..').ProcedureStepDefaultReviewerState;
+    readonly procedureStepEvents: import('..').ProcedureStepEventState;
+    readonly procedureStepReviewers: import('..').ProcedureStepReviewerState;
+    readonly procedureSteps: import('..').ProcedureStepState;
+    readonly rehydrated: import('..').RehydratedState;
+    readonly reports: import('..').ReportState;
+    readonly forms: import('..').FormState;
+    readonly formRevisions: import('..').FormRevisionState;
+    readonly formRevisionAttachments: import('..').FormRevisionAttachmentState;
+    readonly formSubscribers: import('..').FormSubscriberState;
+    readonly formSubmissionFieldValuesAttachments: import('..').FormSubmissionFieldValuesAttachmentState;
+    readonly formSubmissionFieldValues: import('..').FormSubmissionFieldValuesState;
+    readonly formSubmissionCommentAttachments: import('..').FormSubmissionCommentAttachmentState;
+    readonly formSubmissionComments: import('..').FormSubmissionCommentState;
+    readonly formSubmissions: import('..').FormSubmissionState;
+    readonly formIdentifiers: import('..').FormIdentifierState;
+    readonly formIdentifierValues: import('..').FormIdentifierValueState;
+    readonly users: import('..').UserState;
+    readonly emailDomains: import('..').EmailDomainState;
+    readonly documents: import('..').DocumentState;
+    readonly documentAttachments: import('..').DocumentAttachmentState;
+    readonly teams: import('..').TeamState;
+    readonly agents: import('..').AgentsState;
+    readonly issueComments: import('..').IssueCommentState;
+    readonly issueCommentAttachments: import('..').IssueCommentAttachmentState;
+    readonly issueUpdates: import('..').IssueUpdateState;
+    readonly geoImages: import('..').GeoImageSliceState;
+    readonly issueAssociations: import('..').IssueAssociationSliceState;
+    readonly issueTypeFields: import('..').IssueTypeFieldsState;
+    readonly issueTypeFieldValues: import('..').IssueTypeFieldValuesState;
+    readonly issueTypeFieldsAttachments: import('..').IssueTypeFieldsAttachmentState;
+    readonly issueTypeFieldValuesAttachments: import('..').IssueTypeFieldValuesAttachmentState;
+    readonly issueTypeIdentifiers: import('..').IssueTypeIdentifierState;
+    readonly issueTypeIdentifierValues: import('..').IssueTypeIdentifierValueState;
+    readonly issueTypePriorities: import('..').IssueTypePriorityState;
+    readonly issueTypeStatuses: import('..').IssueTypeStatusState;
+    readonly assetTypeFields: import('..').AssetTypeFieldsState;
+    readonly assetTypeFieldValues: import('..').AssetTypeFieldValuesState;
+    readonly assetTypeFieldsAttachments: import('..').AssetTypeFieldsAttachmentState;
+    readonly assetTypeFieldValuesAttachments: import('..').AssetTypeFieldValuesAttachmentState;
+    readonly assetTypeIdentifiers: import('..').AssetTypeIdentifierState;
+    readonly assetTypeIdentifierValues: import('..').AssetTypeIdentifierValueState;
+    readonly assetTypeStatuses: import('..').AssetTypeStatusState;
+    readonly teamMemberships: import('..').TeamMembershipState;
+    readonly outbox: import('..').OutboxState;
+    readonly auth: import('..').AuthState;
+} & {
+    offline: import('@redux-offline/redux-offline/lib/types').OfflineState;
+}) => Stored<GeoImage>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<GeoImage>>) => Stored<GeoImage>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<GeoImage>>) => Stored<GeoImage>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<GeoImage>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<GeoImage>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectGeoImageById: OvermapSelectorWithArgs<GeoImage["uuid"], Stored<GeoImage> | undefined>;
+export declare const selectGeoImagesByIds: (uuids: string[]) => (state: any) => Stored<GeoImage>[];
+export declare const selectGeoImagesOfProject: OvermapSelectorWithArgs<Project["uuid"], Stored<GeoImage>[]>;

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

@@ -1 +1,80 @@
+export * from './agentsSelectors';
+export * from './assetAttachmentSelectors';
+export * from './assetCommentAttachmentSelectors';
+export * from './assetCommentSelectors';
+export * from './assetSelectors';
+export * from './assetTypeAttachmentSelectors';
+export * from './assetTypeFieldValuesAttachmentSelectors';
+export * from './assetTypeFieldValuesSelectors';
+export * from './assetTypeFieldsAttachmentSelectors';
+export * from './assetTypeFieldsSelectors';
+export * from './assetTypeIdentifierSelectors';
+export * from './assetTypeIdentifierValueSelectors';
+export * from './assetTypeSelectors';
+export * from './assetTypeStatusSelectors';
+export * from './authSelectors';
+export * from './documentAttachmentSelectors';
+export * from './documentSelectors';
+export * from './emailDomainsSelectors';
+export * from './formIdentifierSelectors';
+export * from './formIdentifierValueSelectors';
+export * from './formRevisionAttachmentSelectors';
+export * from './formRevisionSelectors';
+export * from './formSelectors';
+export * from './formSubmissionCommentAttachmentSelectors';
+export * from './formSubmissionCommentSelectors';
+export * from './formSubmissionFieldValuesAttachmentSelectors';
+export * from './formSubmissionFieldValuesSelectors';
+export * from './formSubmissionSelectors';
+export * from './formSubscriberSelectors';
+export * from './geoImageSelectors';
+export * from './issueAssociationSelectors';
+export * from './issueAttachmentSelectors';
+export * from './issueCommentAttachmentSelectors';
+export * from './issueCommentSelectors';
+export * from './issueSelectors';
+export * from './issueTypeAttachmentSelectors';
+export * from './issueTypeFieldValuesAttachmentSelectors';
+export * from './issueTypeFieldValuesSelectors';
+export * from './issueTypeFieldsAttachmentSelectors';
+export * from './issueTypeFieldsSelectors';
+export * from './issueTypeIdentifierSelectors';
+export * from './issueTypeIdentifierValueSelectors';
+export * from './issueTypePrioritySelectors';
+export * from './issueTypeSelectors';
+export * from './issueTypeStatusSelectors';
+export * from './issueUpdateSelectors';
+export * from './organizationAccessSelectors';
+export * from './organizationSelectors';
+export * from './outboxSelectors';
+export * from './procedureFieldValuesSelectors';
+export * from './procedureInitiativeSelectors';
+export * from './procedureSelectors';
+export * from './procedureStepAssigneeSelectors';
+export * from './procedureStepCommentSelectors';
+export * from './procedureStepDefaultAssigneeSelectors';
+export * from './procedureStepDefaultReviewerSelectors';
+export * from './procedureStepEventSelectors';
+export * from './procedureStepFieldValuesAttachmentSelectors';
+export * from './procedureStepFieldValuesReviewSelectors';
+export * from './procedureStepFieldValuesSelectors';
+export * from './procedureStepFieldsAttachmentSelectors';
+export * from './procedureStepFieldsSelectors';
+export * from './procedureStepReviewerSelectors';
+export * from './procedureStepSelectors';
+export * from './procedureTypeAttachmentSelectors';
+export * from './procedureTypeFieldValuesAttachmentSelectors';
+export * from './procedureTypeFieldsAttachmentSelectors';
+export * from './procedureTypeFieldsSelectors';
+export * from './procedureTypeSelectors';
+export * from './projectAccessSelectors';
+export * from './projectAttachmentSelectors';
+export * from './projectCommentSelectors';
+export * from './projectFileSelectors';
+export * from './projectSelectors';
+export * from './rehydratedSelectors';
+export * from './reportSelectors';
+export * from './teamMembershipSelectors';
+export * from './teamSelectors';
+export * from './userSelectors';
 export * from './utils';

package/dist/store/selectors/issueAssociationSelectors.d.ts

@@ -0,0 +1,112 @@
+import { Asset, Issue, IssueAssociation, Stored } from '@overmap-ai/common';
+import { OvermapRootState, OvermapSelectorWithArgs } from '../typings';
+export declare const selectIssueAssociationMapping: (state: OvermapRootState) => Record<string, Stored<IssueAssociation>>;
+export declare const selectIssueAssociations: ((state: {
+    readonly assets: import('..').AssetState;
+    readonly assetAttachments: import('..').AssetAttachmentState;
+    readonly assetCommentAttachments: import('..').AssetCommentAttachmentState;
+    readonly assetComments: import('..').AssetCommentState;
+    readonly assetTypes: import('..').AssetTypeState;
+    readonly assetTypeAttachments: import('..').AssetTypeAttachmentState;
+    readonly issues: import('..').IssueState;
+    readonly issueAttachments: import('..').IssueAttachmentState;
+    readonly issueTypes: import('..').IssueTypeState;
+    readonly issueTypeAttachments: import('..').IssueTypeAttachmentState;
+    readonly organizations: import('..').OrganizationState;
+    readonly projects: import('..').ProjectState;
+    readonly projectAttachments: import('..').ProjectAttachmentState;
+    readonly projectComments: import('..').ProjectCommentState;
+    readonly projectAccess: import('..').ProjectAccessState;
+    readonly organizationAccess: import('..').OrganizationAccessState;
+    readonly projectFiles: import('..').ProjectFileState;
+    readonly procedureTypes: import('..').ProcedureTypeState;
+    readonly procedureInitiatives: import('..').ProcedureInitiativeState;
+    readonly procedures: import('..').ProcedureState;
+    readonly procedureTypeFields: import('..').ProcedureTypeFieldsState;
+    readonly procedureFieldValues: import('..').ProcedureFieldValuesState;
+    readonly procedureTypeAttachments: import('..').ProcedureTypeAttachmentState;
+    readonly procedureTypeFieldsAttachments: import('..').ProcedureTypeFieldsAttachmentState;
+    readonly procedureFieldValuesAttachments: import('..').ProcedureFieldValuesAttachmentState;
+    readonly procedureStepFieldsAttachments: import('..').ProcedureStepFieldsAttachmentState;
+    readonly procedureStepFields: import('..').ProcedureStepFieldsState;
+    readonly procedureStepFieldValuesAttachments: import('..').ProcedureStepFieldValuesAttachmentState;
+    readonly procedureStepFieldValues: import('..').ProcedureStepFieldValuesState;
+    readonly procedureStepFieldValuesReviews: import('..').ProcedureStepFieldValuesReviewState;
+    readonly procedureStepAssignees: import('..').ProcedureStepAssigneeState;
+    readonly procedureStepComments: import('..').ProcedureStepCommentState;
+    readonly procedureStepDefaultAssignees: import('..').ProcedureStepDefaultAssigneeState;
+    readonly procedureStepDefaultReviewers: import('..').ProcedureStepDefaultReviewerState;
+    readonly procedureStepEvents: import('..').ProcedureStepEventState;
+    readonly procedureStepReviewers: import('..').ProcedureStepReviewerState;
+    readonly procedureSteps: import('..').ProcedureStepState;
+    readonly rehydrated: import('..').RehydratedState;
+    readonly reports: import('..').ReportState;
+    readonly forms: import('..').FormState;
+    readonly formRevisions: import('..').FormRevisionState;
+    readonly formRevisionAttachments: import('..').FormRevisionAttachmentState;
+    readonly formSubscribers: import('..').FormSubscriberState;
+    readonly formSubmissionFieldValuesAttachments: import('..').FormSubmissionFieldValuesAttachmentState;
+    readonly formSubmissionFieldValues: import('..').FormSubmissionFieldValuesState;
+    readonly formSubmissionCommentAttachments: import('..').FormSubmissionCommentAttachmentState;
+    readonly formSubmissionComments: import('..').FormSubmissionCommentState;
+    readonly formSubmissions: import('..').FormSubmissionState;
+    readonly formIdentifiers: import('..').FormIdentifierState;
+    readonly formIdentifierValues: import('..').FormIdentifierValueState;
+    readonly users: import('..').UserState;
+    readonly emailDomains: import('..').EmailDomainState;
+    readonly documents: import('..').DocumentState;
+    readonly documentAttachments: import('..').DocumentAttachmentState;
+    readonly teams: import('..').TeamState;
+    readonly agents: import('..').AgentsState;
+    readonly issueComments: import('..').IssueCommentState;
+    readonly issueCommentAttachments: import('..').IssueCommentAttachmentState;
+    readonly issueUpdates: import('..').IssueUpdateState;
+    readonly geoImages: import('..').GeoImageSliceState;
+    readonly issueAssociations: import('..').IssueAssociationSliceState;
+    readonly issueTypeFields: import('..').IssueTypeFieldsState;
+    readonly issueTypeFieldValues: import('..').IssueTypeFieldValuesState;
+    readonly issueTypeFieldsAttachments: import('..').IssueTypeFieldsAttachmentState;
+    readonly issueTypeFieldValuesAttachments: import('..').IssueTypeFieldValuesAttachmentState;
+    readonly issueTypeIdentifiers: import('..').IssueTypeIdentifierState;
+    readonly issueTypeIdentifierValues: import('..').IssueTypeIdentifierValueState;
+    readonly issueTypePriorities: import('..').IssueTypePriorityState;
+    readonly issueTypeStatuses: import('..').IssueTypeStatusState;
+    readonly assetTypeFields: import('..').AssetTypeFieldsState;
+    readonly assetTypeFieldValues: import('..').AssetTypeFieldValuesState;
+    readonly assetTypeFieldsAttachments: import('..').AssetTypeFieldsAttachmentState;
+    readonly assetTypeFieldValuesAttachments: import('..').AssetTypeFieldValuesAttachmentState;
+    readonly assetTypeIdentifiers: import('..').AssetTypeIdentifierState;
+    readonly assetTypeIdentifierValues: import('..').AssetTypeIdentifierValueState;
+    readonly assetTypeStatuses: import('..').AssetTypeStatusState;
+    readonly teamMemberships: import('..').TeamMembershipState;
+    readonly outbox: import('..').OutboxState;
+    readonly auth: import('..').AuthState;
+} & {
+    offline: import('@redux-offline/redux-offline/lib/types').OfflineState;
+}) => Stored<IssueAssociation>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<IssueAssociation>>) => Stored<IssueAssociation>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<IssueAssociation>>) => Stored<IssueAssociation>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<IssueAssociation>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<IssueAssociation>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectIssueAssociationById: OvermapSelectorWithArgs<IssueAssociation["uuid"], Stored<IssueAssociation> | undefined>;
+export declare const selectIssueAssociationsByIds: (uuids: string[]) => (state: any) => Stored<IssueAssociation>[];
+export declare const selectIssueAssociationsOfIssues: OvermapSelectorWithArgs<Issue["uuid"][], Stored<IssueAssociation>[]>;
+export declare const selectIssueAssociationsOfIssue: OvermapSelectorWithArgs<Issue["uuid"], Stored<IssueAssociation>[]>;
+export declare const selectIssueAssociationsOfAsset: OvermapSelectorWithArgs<Asset["uuid"], Stored<IssueAssociation>[]>;
+export declare const selectIssueAssociationsOfAssets: OvermapSelectorWithArgs<Asset["uuid"][], Stored<IssueAssociation>[]>;

package/dist/store/selectors/issueAttachmentSelectors.d.ts

@@ -0,0 +1,7 @@
+import { Issue, IssueAttachment, Stored } from '@overmap-ai/common';
+import { OvermapRootState, OvermapSelector, OvermapSelectorWithArgs } from '../typings';
+export declare const selectIssueAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<IssueAttachment>>;
+export declare const selectIssueAttachments: OvermapSelector<Stored<IssueAttachment>[]>;
+export declare const selectAttachmentsOfIssue: OvermapSelectorWithArgs<Issue["uuid"], Stored<IssueAttachment>[]>;
+export declare const selectIssueAttachmentById: OvermapSelectorWithArgs<IssueAttachment["uuid"], Stored<IssueAttachment> | undefined>;
+export declare const selectIssueAttachmentsByIds: (uuids: string[]) => (state: any) => Stored<IssueAttachment>[];

package/dist/store/selectors/issueCommentAttachmentSelectors.d.ts

@@ -0,0 +1,7 @@
+import { IssueComment, IssueCommentAttachment, Stored } from '@overmap-ai/common';
+import { OvermapRootState, OvermapSelector, OvermapSelectorWithArgs } from '../typings';
+export declare const selectIssueCommentAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<IssueCommentAttachment>>;
+export declare const selectIssueCommentAttachments: OvermapSelector<Stored<IssueCommentAttachment>[]>;
+export declare const selectIssueCommentAttachmentById: OvermapSelectorWithArgs<IssueCommentAttachment["uuid"], Stored<IssueCommentAttachment> | undefined>;
+export declare const selectIssueCommentAttachmentsByIds: (uuids: string[]) => (state: any) => Stored<IssueCommentAttachment>[];
+export declare const selectAttachmentsOfIssueComment: OvermapSelectorWithArgs<IssueComment["uuid"], Stored<IssueCommentAttachment>[]>;

package/dist/store/selectors/issueCommentSelectors.d.ts

@@ -0,0 +1,6 @@
+import { IssueComment, Stored } from '@overmap-ai/common';
+import { OvermapRootState, OvermapSelectorWithArgs } from '../typings';
+export declare const selectIssueCommentMapping: (state: OvermapRootState) => Record<string, Stored<IssueComment>>;
+export declare const selectIssueCommentById: OvermapSelectorWithArgs<IssueComment["uuid"], Stored<IssueComment> | undefined>;
+export declare const selectIssueCommentsByIds: (uuids: string[]) => (state: any) => Stored<IssueComment>[];
+export declare const selectCommentsOfIssue: OvermapSelectorWithArgs<IssueComment["uuid"], Stored<IssueComment>[]>;

package/dist/store/selectors/issueSelectors.d.ts

@@ -0,0 +1,9 @@
+import { Issue, IssueType, Project, Stored } from '@overmap-ai/common';
+import { IssueState } from '../slices/issueSlice';
+import { OvermapSelector, OvermapSelectorWithArgs } from '../typings';
+export declare const selectIssueMapping: OvermapSelector<IssueState["instances"]>;
+export declare const selectIssues: OvermapSelector<Stored<Issue>[]>;
+export declare const selectIssueById: OvermapSelectorWithArgs<Issue["uuid"], Stored<Issue> | undefined>;
+export declare const selectIssuesByIds: (uuids: string[]) => (state: any) => Stored<Issue>[];
+export declare const selectIssuesOfProject: OvermapSelectorWithArgs<Project["uuid"], Stored<Issue>[]>;
+export declare const selectIssuesOfIssueType: OvermapSelectorWithArgs<IssueType["uuid"], Stored<Issue>[]>;

package/dist/store/selectors/issueTypeAttachmentSelectors.d.ts

@@ -0,0 +1,7 @@
+import { IssueTypeAttachment, Stored } from '@overmap-ai/common';
+import { OvermapRootState, OvermapSelector, OvermapSelectorWithArgs } from '../typings';
+export declare const selectIssueTypeAttachmentMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeAttachment>>;
+export declare const selectIssueTypeAttachments: OvermapSelector<Stored<IssueTypeAttachment>[]>;
+export declare const selectIssueTypeAttachmentById: OvermapSelectorWithArgs<IssueTypeAttachment["uuid"], Stored<IssueTypeAttachment> | undefined>;
+export declare const selectIssueTypeAttachmentsByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeAttachment>[];
+export declare const selectAttachmentsOfIssueType: (uuid: string) => (state: any) => Stored<IssueTypeAttachment>[];

package/dist/store/selectors/issueTypeFieldValuesAttachmentSelectors.d.ts

@@ -0,0 +1,109 @@
+import { IssueTypeFieldValues, IssueTypeFieldValuesAttachment, Stored } from '@overmap-ai/common';
+import { OvermapRootState, OvermapSelectorWithArgs } from '../typings';
+export declare const selectIssueTypeFieldValuesAttachmentsMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeFieldValuesAttachment>>;
+export declare const selectIssueTypeFieldValuesAttachments: ((state: {
+    readonly assets: import('..').AssetState;
+    readonly assetAttachments: import('..').AssetAttachmentState;
+    readonly assetCommentAttachments: import('..').AssetCommentAttachmentState;
+    readonly assetComments: import('..').AssetCommentState;
+    readonly assetTypes: import('..').AssetTypeState;
+    readonly assetTypeAttachments: import('..').AssetTypeAttachmentState;
+    readonly issues: import('..').IssueState;
+    readonly issueAttachments: import('..').IssueAttachmentState;
+    readonly issueTypes: import('..').IssueTypeState;
+    readonly issueTypeAttachments: import('..').IssueTypeAttachmentState;
+    readonly organizations: import('..').OrganizationState;
+    readonly projects: import('..').ProjectState;
+    readonly projectAttachments: import('..').ProjectAttachmentState;
+    readonly projectComments: import('..').ProjectCommentState;
+    readonly projectAccess: import('..').ProjectAccessState;
+    readonly organizationAccess: import('..').OrganizationAccessState;
+    readonly projectFiles: import('..').ProjectFileState;
+    readonly procedureTypes: import('..').ProcedureTypeState;
+    readonly procedureInitiatives: import('..').ProcedureInitiativeState;
+    readonly procedures: import('..').ProcedureState;
+    readonly procedureTypeFields: import('..').ProcedureTypeFieldsState;
+    readonly procedureFieldValues: import('..').ProcedureFieldValuesState;
+    readonly procedureTypeAttachments: import('..').ProcedureTypeAttachmentState;
+    readonly procedureTypeFieldsAttachments: import('..').ProcedureTypeFieldsAttachmentState;
+    readonly procedureFieldValuesAttachments: import('..').ProcedureFieldValuesAttachmentState;
+    readonly procedureStepFieldsAttachments: import('..').ProcedureStepFieldsAttachmentState;
+    readonly procedureStepFields: import('..').ProcedureStepFieldsState;
+    readonly procedureStepFieldValuesAttachments: import('..').ProcedureStepFieldValuesAttachmentState;
+    readonly procedureStepFieldValues: import('..').ProcedureStepFieldValuesState;
+    readonly procedureStepFieldValuesReviews: import('..').ProcedureStepFieldValuesReviewState;
+    readonly procedureStepAssignees: import('..').ProcedureStepAssigneeState;
+    readonly procedureStepComments: import('..').ProcedureStepCommentState;
+    readonly procedureStepDefaultAssignees: import('..').ProcedureStepDefaultAssigneeState;
+    readonly procedureStepDefaultReviewers: import('..').ProcedureStepDefaultReviewerState;
+    readonly procedureStepEvents: import('..').ProcedureStepEventState;
+    readonly procedureStepReviewers: import('..').ProcedureStepReviewerState;
+    readonly procedureSteps: import('..').ProcedureStepState;
+    readonly rehydrated: import('..').RehydratedState;
+    readonly reports: import('..').ReportState;
+    readonly forms: import('..').FormState;
+    readonly formRevisions: import('..').FormRevisionState;
+    readonly formRevisionAttachments: import('..').FormRevisionAttachmentState;
+    readonly formSubscribers: import('..').FormSubscriberState;
+    readonly formSubmissionFieldValuesAttachments: import('..').FormSubmissionFieldValuesAttachmentState;
+    readonly formSubmissionFieldValues: import('..').FormSubmissionFieldValuesState;
+    readonly formSubmissionCommentAttachments: import('..').FormSubmissionCommentAttachmentState;
+    readonly formSubmissionComments: import('..').FormSubmissionCommentState;
+    readonly formSubmissions: import('..').FormSubmissionState;
+    readonly formIdentifiers: import('..').FormIdentifierState;
+    readonly formIdentifierValues: import('..').FormIdentifierValueState;
+    readonly users: import('..').UserState;
+    readonly emailDomains: import('..').EmailDomainState;
+    readonly documents: import('..').DocumentState;
+    readonly documentAttachments: import('..').DocumentAttachmentState;
+    readonly teams: import('..').TeamState;
+    readonly agents: import('..').AgentsState;
+    readonly issueComments: import('..').IssueCommentState;
+    readonly issueCommentAttachments: import('..').IssueCommentAttachmentState;
+    readonly issueUpdates: import('..').IssueUpdateState;
+    readonly geoImages: import('..').GeoImageSliceState;
+    readonly issueAssociations: import('..').IssueAssociationSliceState;
+    readonly issueTypeFields: import('..').IssueTypeFieldsState;
+    readonly issueTypeFieldValues: import('..').IssueTypeFieldValuesState;
+    readonly issueTypeFieldsAttachments: import('..').IssueTypeFieldsAttachmentState;
+    readonly issueTypeFieldValuesAttachments: import('..').IssueTypeFieldValuesAttachmentState;
+    readonly issueTypeIdentifiers: import('..').IssueTypeIdentifierState;
+    readonly issueTypeIdentifierValues: import('..').IssueTypeIdentifierValueState;
+    readonly issueTypePriorities: import('..').IssueTypePriorityState;
+    readonly issueTypeStatuses: import('..').IssueTypeStatusState;
+    readonly assetTypeFields: import('..').AssetTypeFieldsState;
+    readonly assetTypeFieldValues: import('..').AssetTypeFieldValuesState;
+    readonly assetTypeFieldsAttachments: import('..').AssetTypeFieldsAttachmentState;
+    readonly assetTypeFieldValuesAttachments: import('..').AssetTypeFieldValuesAttachmentState;
+    readonly assetTypeIdentifiers: import('..').AssetTypeIdentifierState;
+    readonly assetTypeIdentifierValues: import('..').AssetTypeIdentifierValueState;
+    readonly assetTypeStatuses: import('..').AssetTypeStatusState;
+    readonly teamMemberships: import('..').TeamMembershipState;
+    readonly outbox: import('..').OutboxState;
+    readonly auth: import('..').AuthState;
+} & {
+    offline: import('@redux-offline/redux-offline/lib/types').OfflineState;
+}) => Stored<IssueTypeFieldValuesAttachment>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<IssueTypeFieldValuesAttachment>>) => Stored<IssueTypeFieldValuesAttachment>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<IssueTypeFieldValuesAttachment>>) => Stored<IssueTypeFieldValuesAttachment>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<IssueTypeFieldValuesAttachment>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<IssueTypeFieldValuesAttachment>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectIssueTypeFieldValuesAttachmentById: OvermapSelectorWithArgs<IssueTypeFieldValuesAttachment["uuid"], Stored<IssueTypeFieldValuesAttachment> | undefined>;
+export declare const selectIssueTypeFieldValuesAttachmentsByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeFieldValuesAttachment>[];
+export declare const selectAttachmentsOfIssueTypeFieldValues: OvermapSelectorWithArgs<IssueTypeFieldValues["uuid"], Stored<IssueTypeFieldValuesAttachment>[]>;

package/dist/store/selectors/issueTypeFieldValuesSelectors.d.ts

@@ -0,0 +1,109 @@
+import { Issue, IssueTypeFieldValues, Stored } from '@overmap-ai/common';
+import { OvermapRootState, OvermapSelectorWithArgs } from '../typings';
+export declare const selectIssueTypeFieldValuesMapping: (state: OvermapRootState) => Record<string, Stored<IssueTypeFieldValues>>;
+export declare const selectIssueTypeFieldValues: ((state: {
+    readonly assets: import('..').AssetState;
+    readonly assetAttachments: import('..').AssetAttachmentState;
+    readonly assetCommentAttachments: import('..').AssetCommentAttachmentState;
+    readonly assetComments: import('..').AssetCommentState;
+    readonly assetTypes: import('..').AssetTypeState;
+    readonly assetTypeAttachments: import('..').AssetTypeAttachmentState;
+    readonly issues: import('..').IssueState;
+    readonly issueAttachments: import('..').IssueAttachmentState;
+    readonly issueTypes: import('..').IssueTypeState;
+    readonly issueTypeAttachments: import('..').IssueTypeAttachmentState;
+    readonly organizations: import('..').OrganizationState;
+    readonly projects: import('..').ProjectState;
+    readonly projectAttachments: import('..').ProjectAttachmentState;
+    readonly projectComments: import('..').ProjectCommentState;
+    readonly projectAccess: import('..').ProjectAccessState;
+    readonly organizationAccess: import('..').OrganizationAccessState;
+    readonly projectFiles: import('..').ProjectFileState;
+    readonly procedureTypes: import('..').ProcedureTypeState;
+    readonly procedureInitiatives: import('..').ProcedureInitiativeState;
+    readonly procedures: import('..').ProcedureState;
+    readonly procedureTypeFields: import('..').ProcedureTypeFieldsState;
+    readonly procedureFieldValues: import('..').ProcedureFieldValuesState;
+    readonly procedureTypeAttachments: import('..').ProcedureTypeAttachmentState;
+    readonly procedureTypeFieldsAttachments: import('..').ProcedureTypeFieldsAttachmentState;
+    readonly procedureFieldValuesAttachments: import('..').ProcedureFieldValuesAttachmentState;
+    readonly procedureStepFieldsAttachments: import('..').ProcedureStepFieldsAttachmentState;
+    readonly procedureStepFields: import('..').ProcedureStepFieldsState;
+    readonly procedureStepFieldValuesAttachments: import('..').ProcedureStepFieldValuesAttachmentState;
+    readonly procedureStepFieldValues: import('..').ProcedureStepFieldValuesState;
+    readonly procedureStepFieldValuesReviews: import('..').ProcedureStepFieldValuesReviewState;
+    readonly procedureStepAssignees: import('..').ProcedureStepAssigneeState;
+    readonly procedureStepComments: import('..').ProcedureStepCommentState;
+    readonly procedureStepDefaultAssignees: import('..').ProcedureStepDefaultAssigneeState;
+    readonly procedureStepDefaultReviewers: import('..').ProcedureStepDefaultReviewerState;
+    readonly procedureStepEvents: import('..').ProcedureStepEventState;
+    readonly procedureStepReviewers: import('..').ProcedureStepReviewerState;
+    readonly procedureSteps: import('..').ProcedureStepState;
+    readonly rehydrated: import('..').RehydratedState;
+    readonly reports: import('..').ReportState;
+    readonly forms: import('..').FormState;
+    readonly formRevisions: import('..').FormRevisionState;
+    readonly formRevisionAttachments: import('..').FormRevisionAttachmentState;
+    readonly formSubscribers: import('..').FormSubscriberState;
+    readonly formSubmissionFieldValuesAttachments: import('..').FormSubmissionFieldValuesAttachmentState;
+    readonly formSubmissionFieldValues: import('..').FormSubmissionFieldValuesState;
+    readonly formSubmissionCommentAttachments: import('..').FormSubmissionCommentAttachmentState;
+    readonly formSubmissionComments: import('..').FormSubmissionCommentState;
+    readonly formSubmissions: import('..').FormSubmissionState;
+    readonly formIdentifiers: import('..').FormIdentifierState;
+    readonly formIdentifierValues: import('..').FormIdentifierValueState;
+    readonly users: import('..').UserState;
+    readonly emailDomains: import('..').EmailDomainState;
+    readonly documents: import('..').DocumentState;
+    readonly documentAttachments: import('..').DocumentAttachmentState;
+    readonly teams: import('..').TeamState;
+    readonly agents: import('..').AgentsState;
+    readonly issueComments: import('..').IssueCommentState;
+    readonly issueCommentAttachments: import('..').IssueCommentAttachmentState;
+    readonly issueUpdates: import('..').IssueUpdateState;
+    readonly geoImages: import('..').GeoImageSliceState;
+    readonly issueAssociations: import('..').IssueAssociationSliceState;
+    readonly issueTypeFields: import('..').IssueTypeFieldsState;
+    readonly issueTypeFieldValues: import('..').IssueTypeFieldValuesState;
+    readonly issueTypeFieldsAttachments: import('..').IssueTypeFieldsAttachmentState;
+    readonly issueTypeFieldValuesAttachments: import('..').IssueTypeFieldValuesAttachmentState;
+    readonly issueTypeIdentifiers: import('..').IssueTypeIdentifierState;
+    readonly issueTypeIdentifierValues: import('..').IssueTypeIdentifierValueState;
+    readonly issueTypePriorities: import('..').IssueTypePriorityState;
+    readonly issueTypeStatuses: import('..').IssueTypeStatusState;
+    readonly assetTypeFields: import('..').AssetTypeFieldsState;
+    readonly assetTypeFieldValues: import('..').AssetTypeFieldValuesState;
+    readonly assetTypeFieldsAttachments: import('..').AssetTypeFieldsAttachmentState;
+    readonly assetTypeFieldValuesAttachments: import('..').AssetTypeFieldValuesAttachmentState;
+    readonly assetTypeIdentifiers: import('..').AssetTypeIdentifierState;
+    readonly assetTypeIdentifierValues: import('..').AssetTypeIdentifierValueState;
+    readonly assetTypeStatuses: import('..').AssetTypeStatusState;
+    readonly teamMemberships: import('..').TeamMembershipState;
+    readonly outbox: import('..').OutboxState;
+    readonly auth: import('..').AuthState;
+} & {
+    offline: import('@redux-offline/redux-offline/lib/types').OfflineState;
+}) => Stored<IssueTypeFieldValues>[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, Stored<IssueTypeFieldValues>>) => Stored<IssueTypeFieldValues>[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, Stored<IssueTypeFieldValues>>) => Stored<IssueTypeFieldValues>[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => Stored<IssueTypeFieldValues>[];
+    dependencies: [(state: OvermapRootState) => Record<string, Stored<IssueTypeFieldValues>>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import('reselect').weakMapMemoize;
+    memoize: typeof import('reselect').weakMapMemoize;
+};
+export declare const selectIssueTypeFieldValuesOfIssue: OvermapSelectorWithArgs<Issue["uuid"], Stored<IssueTypeFieldValues>[]>;
+export declare const selectIssueTypeFieldValuesById: OvermapSelectorWithArgs<IssueTypeFieldValues["uuid"], Stored<IssueTypeFieldValues> | undefined>;
+export declare const selectIssueTypeFieldValuesByIds: (uuids: string[]) => (state: any) => Stored<IssueTypeFieldValues>[];