@kelpie/schemas 0.11.0 → 0.13.0

package/src/company.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod'
 
+import { addressBody, companyAddressesSchema } from './address.ts'
+import type { CompanyAddress } from './address.ts'
 import { customFieldValuesBody, customFieldValuesSchema } from './customField.ts'
 import type { CustomFieldValue, CustomFieldValues } from './customField.ts'
 import { ACCOUNT_TYPES, COMPANY_STAGES, ICP_FITS, SIZE_BANDS } from './values.ts'
@@ -17,8 +19,7 @@ export interface Company extends RecordTimestamps {
   readonly description: string
   readonly stage: CompanyStage
   readonly sizeBand: SizeBand
-  readonly hq: string | null
-  readonly website: string | null
+  readonly addresses: readonly CompanyAddress[]
   readonly accountType: AccountType
   readonly icpFit: IcpFit
   readonly techStack: readonly string[]
@@ -39,8 +40,7 @@ export const companySchema: z.ZodType<Company, unknown> = z
     description: z.string(),
     stage: z.enum(COMPANY_STAGES),
     size_band: z.enum(SIZE_BANDS),
-    hq: z.string().nullable(),
-    website: z.string().nullable(),
+    addresses: companyAddressesSchema,
     account_type: z.enum(ACCOUNT_TYPES),
     icp_fit: z.enum(ICP_FITS),
     tech_stack: z.array(z.string()),
@@ -59,8 +59,7 @@ export const companySchema: z.ZodType<Company, unknown> = z
       description: wire.description,
       stage: wire.stage,
       sizeBand: wire.size_band,
-      hq: wire.hq,
-      website: wire.website,
+      addresses: wire.addresses,
       accountType: wire.account_type,
       icpFit: wire.icp_fit,
       techStack: wire.tech_stack,
@@ -80,8 +79,7 @@ export interface CompanyInput {
   readonly description?: string
   readonly stage?: CompanyStage
   readonly sizeBand?: SizeBand
-  readonly hq?: string | null
-  readonly website?: string | null
+  readonly addresses?: readonly CompanyAddress[]
   readonly accountType?: AccountType
   readonly icpFit?: IcpFit
   readonly techStack?: readonly string[]
@@ -103,8 +101,7 @@ export function companyBody(input: CompanyInput): Record<string, unknown> {
     description: input.description,
     stage: input.stage,
     size_band: input.sizeBand,
-    hq: input.hq,
-    website: input.website,
+    addresses: input.addresses?.map(addressBody),
     account_type: input.accountType,
     icp_fit: input.icpFit,
     tech_stack: input.techStack,

package/src/countries.ts

@@ -0,0 +1,320 @@
+/**
+ * ISO 3166-1 alpha-2 country codes, English short names, and common aliases.
+ *
+ * Import, forms, and the UI picker all resolve a typed name or code to the same
+ * two-letter value. The REST body accepts either and stores the code. An unknown
+ * string is not a country: the API refuses it, and import leaves `country` null
+ * with a row warning rather than guessing.
+ *
+ * This is the only copy. No extra package: `@kelpie/schemas` depends on Zod
+ * alone, so a catalog here stays usable from the browser bundle and the cloud
+ * repo.
+ */
+
+export interface Country {
+  readonly code: string
+  readonly name: string
+  readonly aliases?: readonly string[]
+}
+
+/** Officially assigned ISO 3166-1 alpha-2 codes, English short names. */
+export const COUNTRIES: readonly Country[] = [
+  { code: 'AD', name: 'Andorra' },
+  { code: 'AE', name: 'United Arab Emirates', aliases: ['UAE'] },
+  { code: 'AF', name: 'Afghanistan' },
+  { code: 'AG', name: 'Antigua and Barbuda' },
+  { code: 'AI', name: 'Anguilla' },
+  { code: 'AL', name: 'Albania' },
+  { code: 'AM', name: 'Armenia' },
+  { code: 'AO', name: 'Angola' },
+  { code: 'AQ', name: 'Antarctica' },
+  { code: 'AR', name: 'Argentina' },
+  { code: 'AS', name: 'American Samoa' },
+  { code: 'AT', name: 'Austria' },
+  { code: 'AU', name: 'Australia' },
+  { code: 'AW', name: 'Aruba' },
+  { code: 'AX', name: 'Åland Islands', aliases: ['Aland Islands'] },
+  { code: 'AZ', name: 'Azerbaijan' },
+  { code: 'BA', name: 'Bosnia and Herzegovina' },
+  { code: 'BB', name: 'Barbados' },
+  { code: 'BD', name: 'Bangladesh' },
+  { code: 'BE', name: 'Belgium' },
+  { code: 'BF', name: 'Burkina Faso' },
+  { code: 'BG', name: 'Bulgaria' },
+  { code: 'BH', name: 'Bahrain' },
+  { code: 'BI', name: 'Burundi' },
+  { code: 'BJ', name: 'Benin' },
+  { code: 'BL', name: 'Saint Barthélemy', aliases: ['Saint Barthelemy'] },
+  { code: 'BM', name: 'Bermuda' },
+  { code: 'BN', name: 'Brunei Darussalam', aliases: ['Brunei'] },
+  { code: 'BO', name: 'Bolivia' },
+  { code: 'BQ', name: 'Bonaire, Sint Eustatius and Saba' },
+  { code: 'BR', name: 'Brazil' },
+  { code: 'BS', name: 'Bahamas' },
+  { code: 'BT', name: 'Bhutan' },
+  { code: 'BV', name: 'Bouvet Island' },
+  { code: 'BW', name: 'Botswana' },
+  { code: 'BY', name: 'Belarus' },
+  { code: 'BZ', name: 'Belize' },
+  { code: 'CA', name: 'Canada' },
+  { code: 'CC', name: 'Cocos (Keeling) Islands', aliases: ['Cocos Islands'] },
+  { code: 'CD', name: 'Congo, Democratic Republic of the', aliases: ['DRC', 'Democratic Republic of the Congo'] },
+  { code: 'CF', name: 'Central African Republic' },
+  { code: 'CG', name: 'Congo', aliases: ['Republic of the Congo'] },
+  { code: 'CH', name: 'Switzerland' },
+  { code: 'CI', name: "Côte d'Ivoire", aliases: ['Ivory Coast', "Cote d'Ivoire"] },
+  { code: 'CK', name: 'Cook Islands' },
+  { code: 'CL', name: 'Chile' },
+  { code: 'CM', name: 'Cameroon' },
+  { code: 'CN', name: 'China' },
+  { code: 'CO', name: 'Colombia' },
+  { code: 'CR', name: 'Costa Rica' },
+  { code: 'CU', name: 'Cuba' },
+  { code: 'CV', name: 'Cabo Verde', aliases: ['Cape Verde'] },
+  { code: 'CW', name: 'Curaçao', aliases: ['Curacao'] },
+  { code: 'CX', name: 'Christmas Island' },
+  { code: 'CY', name: 'Cyprus' },
+  { code: 'CZ', name: 'Czechia', aliases: ['Czech Republic'] },
+  { code: 'DE', name: 'Germany' },
+  { code: 'DJ', name: 'Djibouti' },
+  { code: 'DK', name: 'Denmark' },
+  { code: 'DM', name: 'Dominica' },
+  { code: 'DO', name: 'Dominican Republic' },
+  { code: 'DZ', name: 'Algeria' },
+  { code: 'EC', name: 'Ecuador' },
+  { code: 'EE', name: 'Estonia' },
+  { code: 'EG', name: 'Egypt' },
+  { code: 'EH', name: 'Western Sahara' },
+  { code: 'ER', name: 'Eritrea' },
+  { code: 'ES', name: 'Spain' },
+  { code: 'ET', name: 'Ethiopia' },
+  { code: 'FI', name: 'Finland' },
+  { code: 'FJ', name: 'Fiji' },
+  { code: 'FK', name: 'Falkland Islands', aliases: ['Falkland Islands (Malvinas)'] },
+  { code: 'FM', name: 'Micronesia' },
+  { code: 'FO', name: 'Faroe Islands' },
+  { code: 'FR', name: 'France' },
+  { code: 'GA', name: 'Gabon' },
+  { code: 'GB', name: 'United Kingdom', aliases: ['UK', 'Great Britain', 'Britain'] },
+  { code: 'GD', name: 'Grenada' },
+  { code: 'GE', name: 'Georgia' },
+  { code: 'GF', name: 'French Guiana' },
+  { code: 'GG', name: 'Guernsey' },
+  { code: 'GH', name: 'Ghana' },
+  { code: 'GI', name: 'Gibraltar' },
+  { code: 'GL', name: 'Greenland' },
+  { code: 'GM', name: 'Gambia' },
+  { code: 'GN', name: 'Guinea' },
+  { code: 'GP', name: 'Guadeloupe' },
+  { code: 'GQ', name: 'Equatorial Guinea' },
+  { code: 'GR', name: 'Greece' },
+  { code: 'GS', name: 'South Georgia and the South Sandwich Islands' },
+  { code: 'GT', name: 'Guatemala' },
+  { code: 'GU', name: 'Guam' },
+  { code: 'GW', name: 'Guinea-Bissau' },
+  { code: 'GY', name: 'Guyana' },
+  { code: 'HK', name: 'Hong Kong' },
+  { code: 'HM', name: 'Heard Island and McDonald Islands' },
+  { code: 'HN', name: 'Honduras' },
+  { code: 'HR', name: 'Croatia' },
+  { code: 'HT', name: 'Haiti' },
+  { code: 'HU', name: 'Hungary' },
+  { code: 'ID', name: 'Indonesia' },
+  { code: 'IE', name: 'Ireland' },
+  { code: 'IL', name: 'Israel' },
+  { code: 'IM', name: 'Isle of Man' },
+  { code: 'IN', name: 'India' },
+  { code: 'IO', name: 'British Indian Ocean Territory' },
+  { code: 'IQ', name: 'Iraq' },
+  { code: 'IR', name: 'Iran' },
+  { code: 'IS', name: 'Iceland' },
+  { code: 'IT', name: 'Italy' },
+  { code: 'JE', name: 'Jersey' },
+  { code: 'JM', name: 'Jamaica' },
+  { code: 'JO', name: 'Jordan' },
+  { code: 'JP', name: 'Japan' },
+  { code: 'KE', name: 'Kenya' },
+  { code: 'KG', name: 'Kyrgyzstan' },
+  { code: 'KH', name: 'Cambodia' },
+  { code: 'KI', name: 'Kiribati' },
+  { code: 'KM', name: 'Comoros' },
+  { code: 'KN', name: 'Saint Kitts and Nevis' },
+  { code: 'KP', name: "Korea, Democratic People's Republic of", aliases: ['North Korea'] },
+  { code: 'KR', name: 'Korea, Republic of', aliases: ['South Korea'] },
+  { code: 'KW', name: 'Kuwait' },
+  { code: 'KY', name: 'Cayman Islands' },
+  { code: 'KZ', name: 'Kazakhstan' },
+  { code: 'LA', name: 'Lao People\'s Democratic Republic', aliases: ['Laos'] },
+  { code: 'LB', name: 'Lebanon' },
+  { code: 'LC', name: 'Saint Lucia' },
+  { code: 'LI', name: 'Liechtenstein' },
+  { code: 'LK', name: 'Sri Lanka' },
+  { code: 'LR', name: 'Liberia' },
+  { code: 'LS', name: 'Lesotho' },
+  { code: 'LT', name: 'Lithuania' },
+  { code: 'LU', name: 'Luxembourg' },
+  { code: 'LV', name: 'Latvia' },
+  { code: 'LY', name: 'Libya' },
+  { code: 'MA', name: 'Morocco' },
+  { code: 'MC', name: 'Monaco' },
+  { code: 'MD', name: 'Moldova' },
+  { code: 'ME', name: 'Montenegro' },
+  { code: 'MF', name: 'Saint Martin' },
+  { code: 'MG', name: 'Madagascar' },
+  { code: 'MH', name: 'Marshall Islands' },
+  { code: 'MK', name: 'North Macedonia' },
+  { code: 'ML', name: 'Mali' },
+  { code: 'MM', name: 'Myanmar', aliases: ['Burma'] },
+  { code: 'MN', name: 'Mongolia' },
+  { code: 'MO', name: 'Macao', aliases: ['Macau'] },
+  { code: 'MP', name: 'Northern Mariana Islands' },
+  { code: 'MQ', name: 'Martinique' },
+  { code: 'MR', name: 'Mauritania' },
+  { code: 'MS', name: 'Montserrat' },
+  { code: 'MT', name: 'Malta' },
+  { code: 'MU', name: 'Mauritius' },
+  { code: 'MV', name: 'Maldives' },
+  { code: 'MW', name: 'Malawi' },
+  { code: 'MX', name: 'Mexico' },
+  { code: 'MY', name: 'Malaysia' },
+  { code: 'MZ', name: 'Mozambique' },
+  { code: 'NA', name: 'Namibia' },
+  { code: 'NC', name: 'New Caledonia' },
+  { code: 'NE', name: 'Niger' },
+  { code: 'NF', name: 'Norfolk Island' },
+  { code: 'NG', name: 'Nigeria' },
+  { code: 'NI', name: 'Nicaragua' },
+  { code: 'NL', name: 'Netherlands', aliases: ['Holland'] },
+  { code: 'NO', name: 'Norway' },
+  { code: 'NP', name: 'Nepal' },
+  { code: 'NR', name: 'Nauru' },
+  { code: 'NU', name: 'Niue' },
+  { code: 'NZ', name: 'New Zealand' },
+  { code: 'OM', name: 'Oman' },
+  { code: 'PA', name: 'Panama' },
+  { code: 'PE', name: 'Peru' },
+  { code: 'PF', name: 'French Polynesia' },
+  { code: 'PG', name: 'Papua New Guinea' },
+  { code: 'PH', name: 'Philippines' },
+  { code: 'PK', name: 'Pakistan' },
+  { code: 'PL', name: 'Poland' },
+  { code: 'PM', name: 'Saint Pierre and Miquelon' },
+  { code: 'PN', name: 'Pitcairn' },
+  { code: 'PR', name: 'Puerto Rico' },
+  { code: 'PS', name: 'Palestine', aliases: ['Palestinian Territory'] },
+  { code: 'PT', name: 'Portugal' },
+  { code: 'PW', name: 'Palau' },
+  { code: 'PY', name: 'Paraguay' },
+  { code: 'QA', name: 'Qatar' },
+  { code: 'RE', name: 'Réunion', aliases: ['Reunion'] },
+  { code: 'RO', name: 'Romania' },
+  { code: 'RS', name: 'Serbia' },
+  { code: 'RU', name: 'Russian Federation', aliases: ['Russia'] },
+  { code: 'RW', name: 'Rwanda' },
+  { code: 'SA', name: 'Saudi Arabia' },
+  { code: 'SB', name: 'Solomon Islands' },
+  { code: 'SC', name: 'Seychelles' },
+  { code: 'SD', name: 'Sudan' },
+  { code: 'SE', name: 'Sweden' },
+  { code: 'SG', name: 'Singapore' },
+  { code: 'SH', name: 'Saint Helena, Ascension and Tristan da Cunha', aliases: ['Saint Helena'] },
+  { code: 'SI', name: 'Slovenia' },
+  { code: 'SJ', name: 'Svalbard and Jan Mayen' },
+  { code: 'SK', name: 'Slovakia' },
+  { code: 'SL', name: 'Sierra Leone' },
+  { code: 'SM', name: 'San Marino' },
+  { code: 'SN', name: 'Senegal' },
+  { code: 'SO', name: 'Somalia' },
+  { code: 'SR', name: 'Suriname' },
+  { code: 'SS', name: 'South Sudan' },
+  { code: 'ST', name: 'Sao Tome and Principe' },
+  { code: 'SV', name: 'El Salvador' },
+  { code: 'SX', name: 'Sint Maarten' },
+  { code: 'SY', name: 'Syrian Arab Republic', aliases: ['Syria'] },
+  { code: 'SZ', name: 'Eswatini', aliases: ['Swaziland'] },
+  { code: 'TC', name: 'Turks and Caicos Islands' },
+  { code: 'TD', name: 'Chad' },
+  { code: 'TF', name: 'French Southern Territories' },
+  { code: 'TG', name: 'Togo' },
+  { code: 'TH', name: 'Thailand' },
+  { code: 'TJ', name: 'Tajikistan' },
+  { code: 'TK', name: 'Tokelau' },
+  { code: 'TL', name: 'Timor-Leste', aliases: ['East Timor'] },
+  { code: 'TM', name: 'Turkmenistan' },
+  { code: 'TN', name: 'Tunisia' },
+  { code: 'TO', name: 'Tonga' },
+  { code: 'TR', name: 'Türkiye', aliases: ['Turkey'] },
+  { code: 'TT', name: 'Trinidad and Tobago' },
+  { code: 'TV', name: 'Tuvalu' },
+  { code: 'TW', name: 'Taiwan' },
+  { code: 'TZ', name: 'Tanzania' },
+  { code: 'UA', name: 'Ukraine' },
+  { code: 'UG', name: 'Uganda' },
+  { code: 'UM', name: 'United States Minor Outlying Islands' },
+  { code: 'US', name: 'United States', aliases: ['USA', 'United States of America', 'America'] },
+  { code: 'UY', name: 'Uruguay' },
+  { code: 'UZ', name: 'Uzbekistan' },
+  { code: 'VA', name: 'Holy See', aliases: ['Vatican City', 'Vatican'] },
+  { code: 'VC', name: 'Saint Vincent and the Grenadines' },
+  { code: 'VE', name: 'Venezuela' },
+  { code: 'VG', name: 'Virgin Islands (British)', aliases: ['British Virgin Islands'] },
+  { code: 'VI', name: 'Virgin Islands (U.S.)', aliases: ['US Virgin Islands', 'U.S. Virgin Islands'] },
+  { code: 'VN', name: 'Viet Nam', aliases: ['Vietnam'] },
+  { code: 'VU', name: 'Vanuatu' },
+  { code: 'WF', name: 'Wallis and Futuna' },
+  { code: 'WS', name: 'Samoa' },
+  { code: 'YE', name: 'Yemen' },
+  { code: 'YT', name: 'Mayotte' },
+  { code: 'ZA', name: 'South Africa' },
+  { code: 'ZM', name: 'Zambia' },
+  { code: 'ZW', name: 'Zimbabwe' },
+]
+
+export const COUNTRY_CODES: readonly string[] = COUNTRIES.map((country) => country.code)
+
+const COUNTRY_BY_CODE: ReadonlyMap<string, Country> = new Map(
+  COUNTRIES.map((country) => [country.code, country]),
+)
+
+function aliasKey(raw: string): string {
+  return raw.trim().toLowerCase()
+}
+
+const COUNTRY_ALIAS_INDEX: ReadonlyMap<string, string> = ((): ReadonlyMap<string, string> => {
+  const index = new Map<string, string>()
+
+  for (const country of COUNTRIES) {
+    index.set(aliasKey(country.code), country.code)
+    index.set(aliasKey(country.name), country.code)
+
+    for (const alias of country.aliases ?? []) {
+      index.set(aliasKey(alias), country.code)
+    }
+  }
+
+  return index
+})()
+
+export function isCountryCode(code: string): boolean {
+  return COUNTRY_BY_CODE.has(code)
+}
+
+export function countryName(code: string): string | undefined {
+  return COUNTRY_BY_CODE.get(code)?.name
+}
+
+/**
+ * Resolve a typed country to an ISO 3166-1 alpha-2 code.
+ *
+ * Accepts a code in any case (`au`), an English name (`Australia`), or a listed
+ * alias (`USA`). Returns null when the string is empty or not a country we know.
+ */
+export function normaliseCountry(raw: string): string | null {
+  const trimmed = raw.trim()
+
+  if (trimmed.length === 0) {
+    return null
+  }
+
+  return COUNTRY_ALIAS_INDEX.get(aliasKey(trimmed)) ?? null
+}

package/src/dashboard.ts

@@ -252,6 +252,39 @@ const dashboardDecisionSchema: z.ZodType<DashboardDecision, unknown> = z
     dueAt: wire.due_at,
   }))
 
+export interface DashboardUpcomingEvent {
+  readonly id: string
+  readonly name: string
+  readonly startsAt: Date
+  readonly endsAt: Date
+  readonly format: string
+  readonly location: string
+  readonly attendeeCount: number
+  readonly ownerId: string | null
+}
+
+const dashboardUpcomingEventSchema: z.ZodType<DashboardUpcomingEvent, unknown> = z
+  .object({
+    id: idSchema,
+    name: z.string(),
+    starts_at: timestampSchema,
+    ends_at: timestampSchema,
+    format: z.string(),
+    location: z.string(),
+    attendee_count: z.number().int(),
+    owner_id: idSchema.nullable(),
+  })
+  .transform((wire) => ({
+    id: wire.id,
+    name: wire.name,
+    startsAt: wire.starts_at,
+    endsAt: wire.ends_at,
+    format: wire.format,
+    location: wire.location,
+    attendeeCount: wire.attendee_count,
+    ownerId: wire.owner_id,
+  }))
+
 export interface Dashboard {
   readonly generatedAt: Date
   /** The day every signal was measured against, `YYYY-MM-DD`. */
@@ -266,6 +299,7 @@ export interface Dashboard {
   readonly overduePlanItems: DashboardSignal<DashboardPlanItem>
   readonly dueSoonPlanItems: DashboardSignal<DashboardPlanItem>
   readonly partnershipTouchpoints: DashboardSignal<DashboardTouchpoint>
+  readonly upcomingEvents: DashboardSignal<DashboardUpcomingEvent>
   readonly staleContacts: DashboardSignal<DashboardStaleContact>
   readonly recentActivity: readonly DashboardActivity[]
   readonly recentNotes: readonly DashboardNote[]
@@ -283,6 +317,7 @@ export const dashboardSchema: z.ZodType<Dashboard, unknown> = z
     overdue_plan_items: signalSchema(dashboardPlanItemSchema),
     due_soon_plan_items: signalSchema(dashboardPlanItemSchema),
     partnership_touchpoints: signalSchema(dashboardTouchpointSchema),
+    upcoming_events: signalSchema(dashboardUpcomingEventSchema),
     stale_contacts: signalSchema(dashboardStaleContactSchema),
     recent_activity: z.array(dashboardActivitySchema),
     recent_notes: z.array(dashboardNoteSchema),
@@ -299,6 +334,7 @@ export const dashboardSchema: z.ZodType<Dashboard, unknown> = z
       overduePlanItems: wire.overdue_plan_items,
       dueSoonPlanItems: wire.due_soon_plan_items,
       partnershipTouchpoints: wire.partnership_touchpoints,
+      upcomingEvents: wire.upcoming_events,
       staleContacts: wire.stale_contacts,
       recentActivity: wire.recent_activity,
       recentNotes: wire.recent_notes,

package/src/event.ts

@@ -0,0 +1,159 @@
+import { z } from 'zod'
+
+import { customFieldValuesBody, customFieldValuesSchema } from './customField.ts'
+import type { CustomFieldValue, CustomFieldValues } from './customField.ts'
+import {
+  EVENT_ASSOCIATION_TARGET_TYPES,
+  EVENT_FORMATS,
+  EVENT_STATUSES,
+} from './values.ts'
+import type {
+  EventAssociationTargetType,
+  EventFormat,
+  EventStatus,
+} from './values.ts'
+import { definedFields, idSchema, recordTimestamps, timestampSchema } from './wire.ts'
+import type { RecordTimestamps } from './wire.ts'
+
+/** Wire and write shapes for `/v1/events`. */
+
+export interface EventAssociation {
+  readonly targetType: EventAssociationTargetType
+  readonly targetId: string
+}
+
+export interface Event extends RecordTimestamps {
+  readonly id: string
+  readonly name: string
+  readonly kind: string
+  readonly startsAt: Date
+  readonly endsAt: Date
+  readonly timezone: string
+  readonly location: string
+  readonly meetingUrl: string | null
+  readonly format: EventFormat
+  readonly details: string
+  readonly status: EventStatus
+  readonly ownerId: string | null
+  readonly summary: string
+  readonly tags: readonly string[]
+  readonly associations: readonly EventAssociation[]
+  readonly customFields: CustomFieldValues
+}
+
+const associationSchema = z
+  .object({
+    target_type: z.enum(EVENT_ASSOCIATION_TARGET_TYPES),
+    target_id: idSchema,
+  })
+  .transform(
+    (wire): EventAssociation => ({
+      targetType: wire.target_type,
+      targetId: wire.target_id,
+    }),
+  )
+
+export const eventSchema: z.ZodType<Event, unknown> = z
+  .object({
+    id: idSchema,
+    name: z.string(),
+    kind: z.string(),
+    starts_at: timestampSchema,
+    ends_at: timestampSchema,
+    timezone: z.string(),
+    location: z.string(),
+    meeting_url: z.string().nullable(),
+    format: z.enum(EVENT_FORMATS),
+    details: z.string(),
+    status: z.enum(EVENT_STATUSES),
+    owner_id: idSchema.nullable(),
+    summary: z.string(),
+    tags: z.array(z.string()),
+    associations: z.array(associationSchema),
+    custom_fields: customFieldValuesSchema,
+    ...recordTimestamps,
+  })
+  .transform(
+    (wire): Event => ({
+      id: wire.id,
+      name: wire.name,
+      kind: wire.kind,
+      startsAt: wire.starts_at,
+      endsAt: wire.ends_at,
+      timezone: wire.timezone,
+      location: wire.location,
+      meetingUrl: wire.meeting_url,
+      format: wire.format,
+      details: wire.details,
+      status: wire.status,
+      ownerId: wire.owner_id,
+      summary: wire.summary,
+      tags: wire.tags,
+      associations: wire.associations,
+      customFields: wire.custom_fields,
+      createdAt: wire.created_at,
+      updatedAt: wire.updated_at,
+    }),
+  )
+
+function associationBody(association: EventAssociation): Record<string, unknown> {
+  return { target_type: association.targetType, target_id: association.targetId }
+}
+
+export interface EventInput {
+  readonly name?: string
+  readonly kind?: string
+  readonly startsAt?: Date | string
+  readonly endsAt?: Date | string
+  readonly timezone?: string
+  readonly location?: string
+  readonly meetingUrl?: string | null
+  readonly format?: EventFormat
+  readonly details?: string
+  readonly status?: EventStatus
+  readonly ownerId?: string | null
+  readonly summary?: string
+  readonly tags?: readonly string[]
+  readonly associations?: readonly EventAssociation[]
+  readonly customFields?: Readonly<Record<string, CustomFieldValue | null>>
+}
+
+function timestampBody(value: Date | string | undefined): string | undefined {
+  if (value === undefined) {
+    return undefined
+  }
+
+  return value instanceof Date ? value.toISOString() : value
+}
+
+export function eventBody(input: EventInput): Record<string, unknown> {
+  return definedFields({
+    name: input.name,
+    kind: input.kind,
+    starts_at: timestampBody(input.startsAt),
+    ends_at: timestampBody(input.endsAt),
+    timezone: input.timezone,
+    location: input.location,
+    meeting_url: input.meetingUrl,
+    format: input.format,
+    details: input.details,
+    status: input.status,
+    owner_id: input.ownerId,
+    summary: input.summary,
+    tags: input.tags,
+    associations: input.associations?.map(associationBody),
+    custom_fields:
+      input.customFields === undefined ? undefined : customFieldValuesBody(input.customFields),
+  })
+}
+
+export interface CreateEventInput extends EventInput {
+  readonly name: string
+  readonly startsAt: Date | string
+  readonly endsAt: Date | string
+  readonly format: EventFormat
+}
+
+export function createEventBody(input: CreateEventInput): Record<string, unknown> {
+  return eventBody(input)
+}

package/src/eventAssociation.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod'
+
+import { EVENT_ASSOCIATION_TARGET_TYPES } from './values.ts'
+import type { EventAssociationTargetType } from './values.ts'
+import { idSchema } from './wire.ts'
+
+/**
+ * One Event linked to another record, as returned by
+ * `GET /v1/event-associations?target_type=&target_id=`.
+ *
+ * The Event's own `associations` array is the forward view. This is the reverse
+ * tab on a Deal, Company, Role, and so on.
+ */
+
+export interface EventAssociationRow {
+  readonly eventId: string
+  readonly eventName: string
+  readonly targetType: EventAssociationTargetType
+  readonly targetId: string
+}
+
+export const eventAssociationRowSchema: z.ZodType<EventAssociationRow, unknown> = z
+  .object({
+    event_id: idSchema,
+    event_name: z.string(),
+    target_type: z.enum(EVENT_ASSOCIATION_TARGET_TYPES),
+    target_id: idSchema,
+  })
+  .transform(
+    (wire): EventAssociationRow => ({
+      eventId: wire.event_id,
+      eventName: wire.event_name,
+      targetType: wire.target_type,
+      targetId: wire.target_id,
+    }),
+  )

package/src/form.ts

@@ -1,17 +1,17 @@
 import { z } from 'zod'
 
 import {
+  FORM_ATTACH_TARGET_TYPES,
   FORM_FIELD_TYPES,
   FORM_OPTION_VALUE_TYPES,
   FORM_STATUSES,
-  PIPELINE_KINDS,
 } from './values.ts'
 import type {
+  FormAttachTargetType,
   FormFieldMapTarget,
   FormFieldType,
   FormOptionValueType,
   FormStatus,
-  PipelineKind,
 } from './values.ts'
 import { definedFields, idSchema, recordTimestamps } from './wire.ts'
 import type { RecordTimestamps } from './wire.ts'
@@ -69,12 +69,12 @@ export interface FormField {
 }
 
 /**
- * One pre-existing pipeline record every submitter is linked into through
- * `person_links`. `target_type` is fixed at form-write time; the row itself
- * lives in `form_attach_targets` on the server.
+ * One pre-existing record every submitter is linked into. Pipeline kinds use
+ * `person_links`. `event` creates an Attendance instead. The row itself lives
+ * in `form_attach_targets` on the server.
  */
 export interface FormAttachTarget {
-  readonly targetType: PipelineKind
+  readonly targetType: FormAttachTargetType
   readonly targetId: string
 }
 
@@ -181,7 +181,7 @@ const formFieldSchema = z
 
 const attachTargetSchema = z
   .object({
-    target_type: z.enum(PIPELINE_KINDS),
+    target_type: z.enum(FORM_ATTACH_TARGET_TYPES),
     target_id: idSchema,
   })
   .transform(