@kelpie/ui 0.7.0 → 0.9.0

package/src/api/resources/customFields.ts

@@ -0,0 +1,88 @@
+import {
+  createCustomFieldDefinitionBody,
+  customFieldDefinitionBody,
+  customFieldDefinitionSchema,
+} from '@kelpie/schemas'
+import type {
+  CreateCustomFieldDefinitionInput,
+  CustomFieldDefinition,
+  CustomFieldDefinitionInput,
+  CustomFieldObjectType,
+} from '@kelpie/schemas'
+
+import type { QueryParameters } from '../client.ts'
+import { createResourceHooks } from '../resource.ts'
+import type {
+  ListOptions,
+  MutationResult,
+  RecordListResult,
+  RecordResult,
+  UpdateArguments,
+} from '../resource.ts'
+
+/**
+ * `/v1/custom_fields`. Workspace-defined field definitions.
+ *
+ * A record's `custom_fields` values live on that record's own resource — this
+ * hook family manages only the definitions. `alsoInvalidates` wakes every
+ * pipeline record list because a new definition changes what shows up on their
+ * detail pages.
+ */
+
+const customFields = createResourceHooks<
+  CustomFieldDefinition,
+  CreateCustomFieldDefinitionInput,
+  CustomFieldDefinitionInput
+>({
+  name: 'custom_fields',
+  path: '/custom_fields',
+  decode: customFieldDefinitionSchema.parse,
+  createBody: createCustomFieldDefinitionBody,
+  updateBody: customFieldDefinitionBody,
+})
+
+/** The documented filters on `GET /v1/custom_fields`. */
+export interface CustomFieldFilters {
+  readonly term?: string | undefined
+  readonly objectType?: CustomFieldObjectType | undefined
+  readonly limit?: number | undefined
+  readonly sort?: string | undefined
+}
+
+function customFieldQuery(filters: CustomFieldFilters): QueryParameters {
+  return {
+    q: filters.term,
+    object_type: filters.objectType,
+    limit: filters.limit,
+    sort: filters.sort,
+  }
+}
+
+export function useCustomFields(
+  filters: CustomFieldFilters = {},
+  options: ListOptions = {},
+): RecordListResult<CustomFieldDefinition> {
+  return customFields.useList(customFieldQuery(filters), options)
+}
+
+export function useCustomField(id: string | undefined): RecordResult<CustomFieldDefinition> {
+  return customFields.useRecord(id)
+}
+
+export function useCreateCustomField(): MutationResult<
+  CreateCustomFieldDefinitionInput,
+  CustomFieldDefinition
+> {
+  return customFields.useCreate()
+}
+
+export function useUpdateCustomField(): MutationResult<
+  UpdateArguments<CustomFieldDefinitionInput>,
+  CustomFieldDefinition
+> {
+  return customFields.useUpdate()
+}
+
+export function useDeleteCustomField(): MutationResult<string, void> {
+  return customFields.useRemove()
+}

package/src/api/resources/decisions.ts

@@ -33,6 +33,8 @@ export interface DecisionFilters {
   readonly targetId?: string | undefined
   /** Matches the body, the rationale, the target type, and the target's name. */
   readonly term?: string | undefined
+  /** `field` ascending, `-field` descending. Only `decided_at`, `created_at`, `updated_at` are sortable. */
+  readonly sort?: string | undefined
 }
 
 function decisionQuery(filters: DecisionFilters): QueryParameters {
@@ -40,6 +42,7 @@ function decisionQuery(filters: DecisionFilters): QueryParameters {
     target_type: filters.targetType,
     target_id: filters.targetId,
     q: filters.term,
+    sort: filters.sort,
   }
 }
 

package/src/api/resources/emailDomainLinker.ts

@@ -0,0 +1,43 @@
+import { relinkEmailDomainsCountsSchema } from '@kelpie/schemas'
+import type { RelinkEmailDomainsCounts } from '@kelpie/schemas'
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+
+import { useApiClient } from '../context.ts'
+import type { MutationResult } from '../resource.ts'
+import { asMutationResult } from './mutation.ts'
+
+/**
+ * `POST /v1/workspaces/:id/relink-email-domains`: sweep every Company that
+ * carries a domain and stub a Position for every workspace Person whose email
+ * matches. Idempotent — a follow-up run creates no new rows.
+ *
+ * On success invalidates positions, activities, and the person-scoped /
+ * company-scoped list joins so a page open on any of those refreshes with the
+ * new links.
+ */
+
+export interface RelinkInput {
+  readonly workspaceId: string
+}
+
+export function useRelinkEmailDomains(): MutationResult<RelinkInput, RelinkEmailDomainsCounts> {
+  const client = useApiClient()
+  const cache = useQueryClient()
+  const mutation = useMutation({
+    mutationFn: ({ workspaceId }: RelinkInput) =>
+      client.post(
+        `/workspaces/${workspaceId}/relink-email-domains`,
+        {},
+        relinkEmailDomainsCountsSchema.parse,
+      ),
+    onSuccess: async () => {
+      await Promise.all(
+        ['positions', 'activities', 'companies', 'people'].map((name) =>
+          cache.invalidateQueries({ queryKey: [name] }),
+        ),
+      )
+    },
+  })
+
+  return asMutationResult(mutation)
+}

package/src/api/resources/enquiries.ts

@@ -0,0 +1,118 @@
+import { dealSchema, enquiryBody, enquirySchema } from '@kelpie/schemas'
+import type { Deal, Enquiry, EnquiryInput } from '@kelpie/schemas'
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+
+import type { QueryParameters } from '../client.ts'
+import { useApiClient } from '../context.ts'
+import { toError } from '../errors.ts'
+import { createResourceHooks } from '../resource.ts'
+import type {
+  ListOptions,
+  MutationResult,
+  RecordListResult,
+  RecordResult,
+  UpdateArguments,
+} from '../resource.ts'
+
+/**
+ * `/v1/enquiries`. Top-of-funnel: what a website form or an email drops onto
+ * the pipeline before it becomes a deal. Create needs only a name; the API
+ * lands the enquiry in the pipeline's first open stage and hands it to the
+ * caller as owner.
+ */
+
+export interface CreateEnquiryInput extends EnquiryInput {
+  readonly name: string
+}
+
+const enquiries = createResourceHooks<Enquiry, CreateEnquiryInput, EnquiryInput>({
+  name: 'enquiries',
+  path: '/enquiries',
+  decode: enquirySchema.parse,
+  createBody: enquiryBody,
+  updateBody: enquiryBody,
+  // Every write here emits an activity server-side, in the same transaction,
+  // so a timeline rendered on this record is stale the moment the write lands.
+  alsoInvalidates: ['activities'],
+})
+
+/** The documented filters on `GET /v1/enquiries`. */
+export interface EnquiryFilters {
+  /** Matches the enquiry's name, source, summary, tags, and its company's name. */
+  readonly term?: string | undefined
+  /** Exact sources ("Website", "Email", …). Repeats on the wire. */
+  readonly sources?: readonly string[] | undefined
+  /** Enquiries at any of these companies. Repeats on the wire. */
+  readonly companyIds?: readonly string[] | undefined
+  /** Enquiries sitting in any of these stages. Repeats on the wire. */
+  readonly stageIds?: readonly string[] | undefined
+  /** Enquiries any of these people are on. Repeats on the wire. */
+  readonly personIds?: readonly string[] | undefined
+  readonly limit?: number | undefined
+  /** `field` ascending, `-field` descending. Only `name`, `created_at`, `updated_at` are sortable. */
+  readonly sort?: string | undefined
+}
+
+function enquiryQuery(filters: EnquiryFilters): QueryParameters {
+  return {
+    q: filters.term,
+    source: filters.sources,
+    company_id: filters.companyIds,
+    stage_id: filters.stageIds,
+    person_id: filters.personIds,
+    limit: filters.limit,
+    sort: filters.sort,
+  }
+}
+
+export function useEnquiries(
+  filters: EnquiryFilters = {},
+  options: ListOptions = {},
+): RecordListResult<Enquiry> {
+  return enquiries.useList(enquiryQuery(filters), options)
+}
+
+export function useEnquiry(id: string | undefined): RecordResult<Enquiry> {
+  return enquiries.useRecord(id)
+}
+
+export function useCreateEnquiry(): MutationResult<CreateEnquiryInput, Enquiry> {
+  return enquiries.useCreate()
+}
+
+export function useUpdateEnquiry(): MutationResult<UpdateArguments<EnquiryInput>, Enquiry> {
+  return enquiries.useUpdate()
+}
+
+export function useDeleteEnquiry(): MutationResult<string, void> {
+  return enquiries.useRemove()
+}
+
+/**
+ * `POST /v1/enquiries/:id/convert`. Returns the freshly created deal, so the
+ * caller can navigate straight to it. 409 if the enquiry has already been
+ * converted; 422 if it has no linked company yet.
+ */
+export function useConvertEnquiry(): MutationResult<string, Deal> {
+  const client = useApiClient()
+  const queryClient = useQueryClient()
+  const mutation = useMutation({
+    mutationFn: (id: string) =>
+      client.post(`/enquiries/${id}/convert`, {}, dealSchema.parse),
+    onSuccess: () => {
+      // The enquiry, deals list, activities on both sides are all stale.
+      void queryClient.invalidateQueries({ queryKey: ['enquiries'] })
+      void queryClient.invalidateQueries({ queryKey: ['deals'] })
+      void queryClient.invalidateQueries({ queryKey: ['activities'] })
+    },
+  })
+
+  return {
+    run: (input) => {
+      mutation.mutate(input)
+    },
+    runAsync: (input) => mutation.mutateAsync(input),
+    isPending: mutation.isPending,
+    error: toError(mutation.error),
+  }
+}

package/src/api/resources/forms.ts

@@ -5,10 +5,9 @@ import type {
   FormFieldInput,
   FormInput,
   FormSubmission,
+  FormSubmissionLinkTarget,
 } from '@kelpie/schemas'
 import {
-  keepPreviousData,
-  useInfiniteQuery,
   useMutation,
   useQuery,
   useQueryClient,
@@ -16,9 +15,10 @@ import {
 
 import { isRecord } from '../json.ts'
 import type { QueryParameters } from '../client.ts'
+import { ApiError } from '../client.ts'
 import { useApiClient } from '../context.ts'
 import { toError } from '../errors.ts'
-import { createResourceHooks } from '../resource.ts'
+import { createResourceHooks, usePagedList } from '../resource.ts'
 import type {
   MutationResult,
   RecordListResult,
@@ -139,34 +139,72 @@ export function useDeleteForm(): MutationResult<string, void> {
  * The result shape is the same, so a page cannot tell the difference.
  */
 export function useFormSubmissions(formId: string | undefined): RecordListResult<FormSubmission> {
-  const client = useApiClient()
-  const result = useInfiniteQuery({
+  return usePagedList<FormSubmission>({
     queryKey: ['forms', 'submissions', formId ?? ''],
-    queryFn: ({ pageParam }) =>
-      client.list(`/forms/${formId ?? ''}/submissions`, formSubmissionSchema.parse, {
-        ...(pageParam === null ? {} : { cursor: pageParam }),
-      }),
-    initialPageParam: null as string | null,
-    getNextPageParam: (lastPage) => lastPage.nextCursor,
-    placeholderData: keepPreviousData,
+    path: `/forms/${formId ?? ''}/submissions`,
+    decode: formSubmissionSchema.parse,
+    query: {},
     enabled: formId !== undefined,
   })
+}
+
+/**
+ * Submissions that touched one record, newest first.
+ *
+ * Powers the Forms tab on every record type a submission can name (person,
+ * company, position, deal, opportunity, partnership, enquiry). Returns an
+ * empty page for a record no submission has ever named — the server does no
+ * per-target existence check, so a stale id reads the same as a real one.
+ */
+export function useFormSubmissionsForRecord(
+  targetType: FormSubmissionLinkTarget | undefined,
+  targetId: string | undefined,
+): RecordListResult<FormSubmission> {
+  return usePagedList<FormSubmission>({
+    queryKey: ['form-submissions', 'by-target', targetType ?? '', targetId ?? ''],
+    path: '/form-submissions',
+    decode: formSubmissionSchema.parse,
+    query: { target_type: targetType, target_id: targetId },
+    enabled: targetType !== undefined && targetId !== undefined,
+  })
+}
+
+/**
+ * One submission on a form.
+ *
+ * Nested under the form rather than a top-level collection: a submission id is
+ * only meaningful with its form (the field labels live there), and the path
+ * mirrors the list endpoint above it.
+ */
+export function useFormSubmission(
+  formId: string | undefined,
+  submissionId: string | undefined,
+): RecordResult<FormSubmission> {
+  const client = useApiClient()
+  const result = useQuery({
+    queryKey: ['forms', 'submissions', formId ?? '', submissionId ?? ''],
+    queryFn: () =>
+      client.get(
+        `/forms/${formId ?? ''}/submissions/${submissionId ?? ''}`,
+        formSubmissionSchema.parse,
+      ),
+    enabled: formId !== undefined && submissionId !== undefined,
+  })
 
   return {
-    records: result.data?.pages.flatMap((page) => page.items) ?? [],
-    isLoading: result.isPending && formId !== undefined,
+    record: result.data,
+    isLoading: result.isPending && formId !== undefined && submissionId !== undefined,
+    isNotFound: result.error instanceof ApiError && result.error.status === 404,
     error: toError(result.error),
-    hasMore: result.hasNextPage,
-    isLoadingMore: result.isFetchingNextPage,
-    loadMore: () => {
-      void result.fetchNextPage()
-    },
   }
 }
 
 /** What a customer pastes into their site, built server-side from the request origin. */
 export interface EmbedSnippets {
+  /** Standalone hosted page (brand chrome). */
   readonly url: string
+  /** Bare document the iframe snippets load (fields only). */
+  readonly embedUrl: string
   readonly iframeSnippet: string
   readonly scriptSnippet: string
 }
@@ -175,6 +213,7 @@ function decodeSnippets(value: unknown): EmbedSnippets {
   if (
     !isRecord(value) ||
     typeof value.url !== 'string' ||
+    typeof value.embed_url !== 'string' ||
     typeof value.iframe_snippet !== 'string' ||
     typeof value.script_snippet !== 'string'
   ) {
@@ -183,6 +222,7 @@ function decodeSnippets(value: unknown): EmbedSnippets {
 
   return {
     url: value.url,
+    embedUrl: value.embed_url,
     iframeSnippet: value.iframe_snippet,
     scriptSnippet: value.script_snippet,
   }

package/src/api/resources/handbookPages.ts

@@ -42,7 +42,7 @@ function handbookQuery(filters: HandbookPageFilters): QueryParameters {
  * The same call the kanban board makes for its stages, for the same reason: a
  * tree cannot be drawn from part of itself, and a page whose parent is on the
  * next page of results would render at the top level as though somebody had
- * moved it there. The caller reads `hasMore` and says so rather than drawing a
+ * moved it there. The caller reads `hasNext` and says so rather than drawing a
  * tree with holes in it.
  */
 export function useHandbookPages(filters: HandbookPageFilters = {}): RecordListResult<HandbookPage> {

package/src/api/resources/importJobs.ts

@@ -34,6 +34,11 @@ export interface CreateImportJobInput {
   /** People import only: what to do with a row naming a company that is not here yet. */
   readonly onMissingCompany: OnMissingCompany
   readonly matchKeyId: string
+  /**
+   * People import only: the consent purpose a row's `consent_status` grants.
+   * Required whenever the map names `consent_status` or `consent_at`.
+   */
+  readonly consentPurposeId?: string | null
   /**
    * Absent on the first upload, so the server derives one from the source preset
    * and the file's own headers. The mapping screen sends the corrected map back
@@ -57,6 +62,10 @@ function jobForm(input: CreateImportJobInput): FormData {
     form.set('column_map', JSON.stringify(input.columnMap))
   }
 
+  if (input.consentPurposeId != null && input.consentPurposeId.length > 0) {
+    form.set('consent_purpose_id', input.consentPurposeId)
+  }
+
   return form
 }
 

package/src/api/resources/listMembers.ts

@@ -0,0 +1,173 @@
+import {
+  addListMemberBody,
+  listMemberSchema,
+  listMembershipSchema,
+} from '@kelpie/schemas'
+import type {
+  AddListMemberInput,
+  ListMember,
+  ListMembership,
+  RecordTargetType,
+} from '@kelpie/schemas'
+import {
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from '@tanstack/react-query'
+import type { InfiniteData } from '@tanstack/react-query'
+
+import type { Page } from '../client.ts'
+import { useApiClient } from '../context.ts'
+import { toError } from '../errors.ts'
+import { usePagedList } from '../resource.ts'
+import type { MutationResult, RecordListResult } from '../resource.ts'
+
+/**
+ * `/v1/lists/:id/members`. Nested per list, so the standard resource hook cannot
+ * mint the path. Built by hand with the same read/write cache invalidation
+ * pattern the other resources use.
+ */
+
+type MembersData = InfiniteData<Page<ListMember>, string | null>
+
+function membersKey(listId: string): readonly unknown[] {
+  return ['lists', 'members', listId]
+}
+
+function membershipsKey(targetType: string, targetId: string): readonly unknown[] {
+  return ['lists', 'memberships', targetType, targetId]
+}
+
+/** The list-level entries whose cached counts change when a member is added or removed. */
+function listsInvalidations(): readonly unknown[] {
+  return ['lists', 'list']
+}
+
+export interface ListMembershipsResult {
+  readonly memberships: readonly ListMembership[]
+  readonly isLoading: boolean
+  readonly error: Error | null
+}
+
+/**
+ * "Which lists is this record on?"
+ *
+ * A plain `useQuery` rather than the paged read: the endpoint is not paged.
+ * The invalidation key overlaps with `useListMembers` so adding or removing on
+ * either side refreshes both views.
+ */
+export function useListMembershipsFor(
+  targetType: RecordTargetType | undefined,
+  targetId: string | undefined,
+): ListMembershipsResult {
+  const client = useApiClient()
+  const enabled = targetType !== undefined && targetId !== undefined
+  const result = useQuery({
+    queryKey: membershipsKey(targetType ?? '', targetId ?? ''),
+    queryFn: async () => {
+      const page = await client.list(
+        '/list-memberships',
+        listMembershipSchema.parse,
+        { target_type: targetType, target_id: targetId },
+      )
+
+      return page.items
+    },
+    enabled,
+  })
+
+  return {
+    memberships: result.data ?? [],
+    isLoading: result.isPending && enabled,
+    error: toError(result.error),
+  }
+}
+
+export function useListMembers(listId: string | undefined): RecordListResult<ListMember> {
+  return usePagedList<ListMember>({
+    queryKey: membersKey(listId ?? ''),
+    path: `/lists/${listId ?? ''}/members`,
+    decode: listMemberSchema.parse,
+    query: {},
+    enabled: listId !== undefined,
+  })
+}
+
+export interface AddMemberArguments {
+  readonly listId: string
+  readonly input: AddListMemberInput
+}
+
+export function useAddListMember(): MutationResult<AddMemberArguments, ListMember> {
+  const client = useApiClient()
+  const queryClient = useQueryClient()
+  const mutation = useMutation({
+    mutationFn: ({ listId, input }: AddMemberArguments) =>
+      client.post(`/lists/${listId}/members`, addListMemberBody(input), listMemberSchema.parse),
+    onSettled: (_record, _error, { listId }) => {
+      void queryClient.invalidateQueries({ queryKey: membersKey(listId) })
+      void queryClient.invalidateQueries({ queryKey: listsInvalidations() })
+      void queryClient.invalidateQueries({ queryKey: ['lists', 'memberships'] })
+    },
+  })
+
+  return {
+    run: (input) => {
+      mutation.mutate(input)
+    },
+    runAsync: (input) => mutation.mutateAsync(input),
+    isPending: mutation.isPending,
+    error: toError(mutation.error),
+  }
+}
+
+export interface RemoveMemberArguments {
+  readonly listId: string
+  readonly id: string
+}
+
+export function useRemoveListMember(): MutationResult<RemoveMemberArguments, void> {
+  const client = useApiClient()
+  const queryClient = useQueryClient()
+  const mutation = useMutation({
+    mutationFn: ({ listId, id }: RemoveMemberArguments) =>
+      client.delete(`/lists/${listId}/members/${id}`),
+    onMutate: async ({ listId, id }) => {
+      await queryClient.cancelQueries({ queryKey: membersKey(listId) })
+      const previous = queryClient.getQueryData<MembersData>(membersKey(listId))
+
+      queryClient.setQueryData<MembersData>(membersKey(listId), (data) =>
+        data === undefined
+          ? data
+          : {
+              ...data,
+              pages: data.pages.map((page) => ({
+                ...page,
+                items: page.items.filter((item) => item.id !== id),
+              })),
+            },
+      )
+
+      return { previous }
+    },
+    onError: (_error, { listId }, context) => {
+      if (context?.previous !== undefined) {
+        queryClient.setQueryData(membersKey(listId), context.previous)
+      }
+    },
+    onSettled: (_record, _error, { listId }) => {
+      void queryClient.invalidateQueries({ queryKey: membersKey(listId) })
+      void queryClient.invalidateQueries({ queryKey: listsInvalidations() })
+      void queryClient.invalidateQueries({ queryKey: ['lists', 'memberships'] })
+    },
+  })
+
+  return {
+    run: (input) => {
+      mutation.mutate(input)
+    },
+    runAsync: (input) => mutation.mutateAsync(input),
+    isPending: mutation.isPending,
+    error: toError(mutation.error),
+  }
+}

package/src/api/resources/lists.ts

@@ -0,0 +1,61 @@
+import { createListBody, listBody, listSchema } from '@kelpie/schemas'
+import type { CreateListInput, List, ListInput, RecordTargetType } from '@kelpie/schemas'
+
+import type { QueryParameters } from '../client.ts'
+import { createResourceHooks } from '../resource.ts'
+import type {
+  ListOptions,
+  MutationResult,
+  RecordListResult,
+  RecordResult,
+  UpdateArguments,
+} from '../resource.ts'
+
+/** `/v1/lists`. A list holds records of one type; the type is fixed at creation. */
+
+const lists = createResourceHooks<List, CreateListInput, ListInput>({
+  name: 'lists',
+  path: '/lists',
+  decode: listSchema.parse,
+  createBody: createListBody,
+  updateBody: listBody,
+})
+
+export interface ListFilters {
+  readonly term?: string | undefined
+  readonly targetType?: RecordTargetType | undefined
+  readonly limit?: number | undefined
+  readonly sort?: string | undefined
+}
+
+function listsQuery(filters: ListFilters): QueryParameters {
+  return {
+    q: filters.term,
+    target_type: filters.targetType,
+    limit: filters.limit,
+    sort: filters.sort,
+  }
+}
+
+export function useLists(
+  filters: ListFilters = {},
+  options: ListOptions = {},
+): RecordListResult<List> {
+  return lists.useList(listsQuery(filters), options)
+}
+
+export function useList(id: string | undefined): RecordResult<List> {
+  return lists.useRecord(id)
+}
+
+export function useCreateList(): MutationResult<CreateListInput, List> {
+  return lists.useCreate()
+}
+
+export function useUpdateList(): MutationResult<UpdateArguments<ListInput>, List> {
+  return lists.useUpdate()
+}
+
+export function useDeleteList(): MutationResult<string, void> {
+  return lists.useRemove()
+}

package/src/api/resources/opportunities.ts

@@ -41,6 +41,8 @@ export interface OpportunityFilters {
   readonly companyIds?: readonly string[] | undefined
   /** Opportunities sitting in any of these stages. Repeats on the wire. */
   readonly stageIds?: readonly string[] | undefined
+  /** Opportunities any of these people are on. Repeats on the wire. */
+  readonly personIds?: readonly string[] | undefined
   readonly limit?: number | undefined
   /** `field` ascending, `-field` descending. Only `name`, `created_at`, `updated_at` are sortable. */
   readonly sort?: string | undefined
@@ -52,6 +54,7 @@ function opportunityQuery(filters: OpportunityFilters): QueryParameters {
     kind: filters.kinds,
     company_id: filters.companyIds,
     stage_id: filters.stageIds,
+    person_id: filters.personIds,
     limit: filters.limit,
     sort: filters.sort,
   }

package/src/api/resources/people.ts

@@ -25,7 +25,10 @@ const people = createResourceHooks<Person, CreatePersonInput, PersonInput>({
   updateBody: personBody,
   // Every write here emits an activity server-side, in the same transaction, so
   // a timeline rendered on this record is stale the moment the write lands.
-  alsoInvalidates: ['activities'],
+  // Setting or changing the email may also auto-link a Position, which changes
+  // both the person's position list and the `?person_id=` companies list that
+  // names the far side — without the latter, the new row renders as "Unknown".
+  alsoInvalidates: ['activities', 'positions', 'companies'],
 })
 
 /** The documented filters on `GET /v1/people`. There is no generic filter DSL. */