@vuoma/sdk 0.1.1 → 0.2.0

package/src/index.js

@@ -1,6 +1,7 @@
+import { bookingInput, visitInput, bookingId, feeAmount, validBookingResult, validQuote, validVisitResult, availabilityRange, validAvailability, validBookingCatalog, accountInput, displayName, emailCode, validCapability, accountResolution } from "./member-contracts.js"
+
 // Public package: no environment reads, provider clients, persistence or secrets.
 const slugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u
-const appKeyPattern = /^vuoma_pk_[0-9a-f]{32}$/u
 const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu
 const timestampPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/u
 const maximumRange = 63 * 24 * 60 * 60 * 1000
@@ -135,26 +136,45 @@ export function createVuomaClient(options) {
   if (typeof organizationSlug !== "string" || organizationSlug.length < 2 || organizationSlug.length > 80 || !slugPattern.test(organizationSlug)) throw new TypeError("Use an exact organization slug.")
   const organizationId = options.organizationId
   if (organizationId !== undefined && !uuid(organizationId)) throw new TypeError("Use a valid organization ID.")
-  const appKey = options.appKey
-  if (appKey !== undefined && (typeof appKey !== "string" || !appKeyPattern.test(appKey))) throw new TypeError("Use a publishable Vuoma app key.")
   const requestFetch = options.fetch ?? globalThis.fetch
   if (typeof requestFetch !== "function") throw new TypeError("A fetch implementation is required.")
   const tokenAdapter = options.tokenAdapter
   if (tokenAdapter !== undefined && (!object(tokenAdapter) || typeof tokenAdapter.getSession !== "function")) throw new TypeError("Provide a member session adapter.")
+  const bookingTokenAdapter = options.bookingTokenAdapter
+  if (bookingTokenAdapter !== undefined && (!object(bookingTokenAdapter) || typeof bookingTokenAdapter.getCredential !== "function" || tokenAdapter)) throw new TypeError("Provide either a member session adapter or a booking credential adapter.")
   const maximumBytes = options.maximumResponseBytes ?? 2 * 1024 * 1024
   if (!Number.isSafeInteger(maximumBytes) || maximumBytes < 1024 || maximumBytes > 16 * 1024 * 1024) throw new TypeError("Use a response limit between 1 KiB and 16 MiB.")
   const memberRoot = `/api/v1/o/${organizationSlug}/member`
+  const selfRoot = `/api/v1/o/${organizationSlug}/me`
+  const authRoot = `/api/v1/o/${organizationSlug}/auth`
 
   async function readSession() {
     if (!tokenAdapter) throw invalidSession()
     return verifySession(await tokenAdapter.getSession(), organizationSlug, organizationId)
   }
 
+  async function readBookingSession() {
+    if (!bookingTokenAdapter) return readSession()
+    const credential = await bookingTokenAdapter.getCredential()
+    if (!object(credential) || credential.organization_slug !== organizationSlug) throw invalidSession()
+    const claims = memberClaims(credential.access_token)
+    if (organizationId && claims.app_metadata.organization_id !== organizationId) throw invalidSession()
+    return { session: credential, identity: `${organizationSlug}:${claims.sub}:${claims.session_id}:${claims.app_metadata.organization_id}` }
+  }
+  function checkSignal(signal) {
+    if (signal?.aborted) { const error = new Error("The request was cancelled."); error.name = "AbortError"; throw error }
+  }
+  function checked(value, valid) { if (!valid(value)) throw invalidResponse(); return value }
+  function setupResult(value) {
+    if (value.ok !== true || value.organization_slug != null && value.organization_slug !== organizationSlug) throw invalidResponse()
+    return value
+  }
+
   async function request(path, { method = "GET", body, accessToken, signal, query, privateResponse = false, empty = false } = {}) {
+    checkSignal(signal)
     const url = new URL(path, origin)
     if (query) for (const [key, value] of Object.entries(query)) url.searchParams.set(key, value)
     const headers = { accept: "application/json" }
-    if (appKey !== undefined) headers["x-vuoma-app-key"] = appKey
     if (body !== undefined) headers["content-type"] = "application/json"
     if (accessToken) headers.authorization = `Bearer ${accessToken}`
     const response = await requestFetch(url.href, {
@@ -162,11 +182,13 @@ export function createVuomaClient(options) {
       cache: privateResponse ? "no-store" : "default",
       ...(body === undefined ? {} : { body: JSON.stringify(body) }),
     })
+    checkSignal(signal)
     // Custom fetch adapters must also honor the no-redirect destination boundary.
     if (response.redirected || (response.url && response.url !== url.href)) throw invalidResponse()
     const declared = Number(response.headers.get("content-length"))
     if (Number.isFinite(declared) && declared > maximumBytes) throw invalidResponse()
     const text = await response.text()
+    checkSignal(signal)
     if (utf8Length(text) > maximumBytes) throw invalidResponse()
     let value
     try { value = text ? JSON.parse(text) : null } catch { if (response.ok) throw invalidResponse() }
@@ -185,12 +207,14 @@ export function createVuomaClient(options) {
     return value
   }
 
-  async function accountRequest(path, requestOptions = {}, parse = value => value) {
-    const initial = await readSession()
-    const value = await request(`${memberRoot}${path}`, { ...requestOptions, accessToken: initial.session.access_token, privateResponse: true })
-    const current = await readSession()
+  async function accountRequest(path, requestOptions = {}, parse = value => value, booking = false) {
+    const read = booking ? readBookingSession : readSession
+    const initial = await read()
+    const value = await request(`${selfRoot}${path}`, { ...requestOptions, accessToken: initial.session.access_token, privateResponse: true })
+    const current = await read()
+    checkSignal(requestOptions.signal)
     if (current.identity !== initial.identity) throw new VuomaApiError(401, "member_session_changed", "Your signed-in account changed. Try again.")
-    return parse(value, initial.session.customer.id)
+    return parse(value, initial.session.customer?.id)
   }
 
   function profile(value, customerId) {
@@ -225,24 +249,74 @@ export function createVuomaClient(options) {
         if (value.schedule.sessions.length > 250) throw invalidResponse()
         return value
       },
+      async getBookingCatalog({ signal } = {}) {
+        return checked(await request(`${memberRoot}/booking-catalog`, { signal }), validBookingCatalog)
+      },
+      async getAppointmentAvailability({ from, to, signal }) {
+        const range = availabilityRange({ from, to })
+        return checked(await request(`${memberRoot}/availability`, { query: range, signal }), value => validAvailability(value, range))
+      },
       async getCatalog({ includeCreditPurchases = false, signal } = {}) {
         return catalog(await request(`${memberRoot}/catalog`, { signal, query: includeCreditPurchases ? { include_credit_purchases: "true" } : undefined }))
       },
     }),
     auth: Object.freeze({
+      async requestAccountCode({ mode, email, signupIntent, displayName: name, signal }) {
+        accountInput({ mode, email, signupIntent })
+        const body = mode === "signup" ? { email, signup_intent: signupIntent, ...(["new", "auto"].includes(signupIntent) ? { display_name: displayName(name) } : {}) } : { email }
+        const value = setupResult(await request(`${authRoot}/${mode === "signup" ? "sign-up" : "recovery"}`, { method: "POST", body, signal, privateResponse: true }))
+        if (value.mode !== mode || value.requires_email_code !== true) throw invalidResponse()
+        return { ok: true, mode, requires_email_code: true }
+      },
+      async confirmAccountCode({ mode, email, signupIntent, code, signal }) {
+        accountInput({ mode, email, signupIntent })
+        const resolve = mode === "signup" && ["auto", "activate"].includes(signupIntent)
+        const path = mode === "signup" ? resolve ? "account" : "sign-up" : "recovery"
+        const value = setupResult(await request(`${authRoot}/${path}/confirm-code`, { method: "POST", body: { email, code: emailCode(code) }, signal, privateResponse: true }))
+        if (!validCapability(value.capability)) throw invalidResponse()
+        let resolution
+        try { if (resolve) resolution = accountResolution(value.account_resolution) } catch { throw invalidResponse() }
+        return { organization_slug: organizationSlug, value: value.capability, ...(resolution ? { account_resolution: resolution } : {}) }
+      },
+      async completePassword({ capability, password, signal }) {
+        if (!object(capability) || capability.organization_slug !== organizationSlug || !validCapability(capability.value)) throw invalidSession()
+        if (typeof password !== "string" || !password || password.length > 1024) throw new TypeError("Provide a password.")
+        setupResult(await request(`${authRoot}/password`, { method: "POST", body: { capability: capability.value, password, password_confirmation: password }, signal, privateResponse: true }))
+      },
       async signIn({ email, password, signal }) {
         if (typeof email !== "string" || !email.trim() || email.length > 320 || typeof password !== "string" || !password || password.length > 1024) throw new TypeError("Provide an email address and password.")
-        return sessionResponse(await request(`${memberRoot}/auth/sign-in`, { method: "POST", body: { email, password }, signal, privateResponse: true }), organizationSlug, organizationId)
+        return sessionResponse(await request(`${authRoot}/sign-in`, { method: "POST", body: { email, password }, signal, privateResponse: true }), organizationSlug, organizationId)
       },
       async refresh({ refreshToken: token, signal }) {
-        return sessionResponse(await request("/api/v1/member/auth/refresh", { method: "POST", body: { refresh_token: refreshToken(token) }, signal, privateResponse: true }), organizationSlug, organizationId)
+        return sessionResponse(await request(`${authRoot}/refresh`, { method: "POST", body: { refresh_token: refreshToken(token) }, signal, privateResponse: true }), organizationSlug, organizationId)
       },
       async signOut({ refreshToken: token, signal }) {
-        await request("/api/v1/member/auth/sign-out", { method: "POST", body: { refresh_token: refreshToken(token) }, signal, privateResponse: true, empty: true })
+        await request(`${authRoot}/sign-out`, { method: "POST", body: { refresh_token: refreshToken(token) }, signal, privateResponse: true, empty: true })
       },
     }),
     member: Object.freeze({
-      getProfile({ signal } = {}) { return accountRequest("/profile", { signal }, profile) },
+      bookClass(input, { signal } = {}) {
+        const body = bookingInput(input)
+        return accountRequest("/commerce/bookings", { method: "POST", body, signal }, value => checked(value, validBookingResult), true)
+      },
+      getCancellationQuote(id, { signal } = {}) {
+        bookingId(id)
+        return accountRequest(`/commerce/bookings/${id}/cancellation-quote`, { signal, query: { include_booking_policy_context: "true" } }, value => checked(value, result => result.api_version === 1 && result.booking_id === id && validQuote(result.quote)), true)
+      },
+      cancelBooking(id, { expectedFeeAmount, signal } = {}) {
+        bookingId(id)
+        const body = expectedFeeAmount === undefined ? {} : { expected_fee_amount: feeAmount(expectedFeeAmount) }
+        return accountRequest(`/commerce/bookings/${id}/cancel`, { method: "POST", body, signal }, value => checked(value, result => result.api_version === 1 && result.booking_id === id && result.status === "cancelled" && result.canceled === true && (result.cancellation_quote === null || validQuote(result.cancellation_quote))), true)
+      },
+      bookAppointmentVisit(input, { signal } = {}) {
+        const body = visitInput(input)
+        return accountRequest("/commerce/visits", { method: "POST", body, signal }, value => checked(value, result => validVisitResult(result, body)), true)
+      },
+      getAppointmentVisit(input, { signal } = {}) {
+        const body = visitInput(input)
+        return accountRequest(`/commerce/visits/${body.source_request_id}`, { signal }, value => checked(value, result => validVisitResult(result, body)), true)
+      },
+      getProfile({ signal } = {}) { return accountRequest("/profile", { signal, query: { view: "basic" } }, profile) },
       updateProfile(changes, { signal } = {}) {
         const allowed = new Set(["first_name", "last_name", "phone", "birth_date"])
         if (!object(changes) || !Object.keys(changes).length || Object.entries(changes).some(([key, value]) =>

package/src/member-contracts.js

@@ -0,0 +1,98 @@
+// Reviewed public wire checks. No private package or server imports.
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value)
+const uuid = value => typeof value === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(value)
+const integer = (value, min = 0, max = Number.MAX_SAFE_INTEGER) => Number.isSafeInteger(value) && value >= min && value <= max
+const text = (value, max, min = 0) => typeof value === 'string' && value.length >= min && value.length <= max
+const timestamp = value => text(value, 64) && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/u.test(value) && Number.isFinite(Date.parse(value)) && new Date(`${value.slice(0, 10)}T00:00:00Z`).toISOString().slice(0, 10) === value.slice(0, 10)
+const exact = (value, allowed) => object(value) && Object.keys(value).every(key => allowed.includes(key))
+const selectionKeys = ['service_offering_id', 'starts_at', 'ends_at', 'credit_cost']
+const selection = value => object(value) && uuid(value.service_offering_id) && timestamp(value.starts_at) && timestamp(value.ends_at) && integer(value.credit_cost, 1, 100_000) && Date.parse(value.ends_at) > Date.parse(value.starts_at) && Date.parse(value.ends_at) - Date.parse(value.starts_at) <= 86_400_000
+const check = (condition, message = 'Invalid member request.') => { if (!condition) throw new TypeError(message) }
+
+export function bookingInput(value) {
+  const fields = ['service_session_id', 'entitlement_id', 'source_request_id', 'policy_version', 'policy_consent', 'payment_authorized', 'payment_authorization_id']
+  check(exact(value, fields))
+  const result = { ...value }
+  for (const key of ['service_session_id', 'source_request_id', 'entitlement_id']) {
+    if (key === 'entitlement_id' && result[key] == null) continue
+    check(typeof result[key] === 'string')
+    result[key] = result[key].trim().toLowerCase()
+    check(uuid(result[key]))
+  }
+  const policy = fields.slice(3)
+  if (policy.some(key => key in result)) check(uuid(result.policy_version) && result.policy_consent === true && result.payment_authorized === true && uuid(result.payment_authorization_id))
+  return result
+}
+export function visitInput(value) {
+  check(exact(value, ['source_request_id', 'appointments']) && uuid(value.source_request_id) && Array.isArray(value.appointments) && value.appointments.length >= 1 && value.appointments.length <= 10)
+  let previousEnd = null
+  const appointments = value.appointments.map(item => {
+    check(exact(item, selectionKeys) && selection(item) && (previousEnd === null || Date.parse(item.starts_at) >= previousEnd))
+    previousEnd = Date.parse(item.ends_at)
+    return { ...item }
+  })
+  return { source_request_id: value.source_request_id, appointments }
+}
+export function bookingId(value) { check(uuid(value), 'Use a valid booking ID.'); return value }
+export function feeAmount(value) { check(integer(value), 'Use a nonnegative fee amount in minor currency units.'); return value }
+export function validBookingResult(value) {
+  return object(value) && value.api_version === 1 && object(value.booking) && uuid(value.booking.id) && ['confirmed', 'waitlisted', 'cancelled', 'attended', 'no_show'].includes(value.booking.status) && object(value.redemption) && uuid(value.redemption.id) && ['waitlisted', 'reserved', 'consumed', 'released', 'reversed'].includes(value.redemption.status)
+}
+export function validQuote(quote) {
+  if (!object(quote) || !(quote.policy_version === null || uuid(quote.policy_version)) || !integer(quote.fee_amount) || !/^[a-z]{3}$/u.test(quote.currency ?? '') || !timestamp(quote.quoted_at) ||
+    !['can_cancel', 'late', 'grace_applies', 'demand_observed', 'waive_if_filled', 'credit_return'].every(key => typeof quote[key] === 'boolean') ||
+    !['late_cancellation_deadline', 'grace_until'].every(key => quote[key] === null || timestamp(quote[key])) ||
+    !['no_policy', 'fees_disabled', 'legacy_booking', 'on_time', 'waitlisted', 'booking_grace', 'quiet_class', 'late_fee_if_unfilled', 'seat_refilled', 'teacher_assignment', 'started'].includes(quote.reason)) return false
+  if (quote.fee_amount > 0 && (!quote.can_cancel || !quote.late || quote.grace_applies || !quote.policy_version || quote.reason !== 'late_fee_if_unfilled')) return false
+  return !quote.grace_applies || Boolean(quote.grace_until)
+}
+export function validVisitResult(value, request) {
+  if (!object(value) || value.api_version !== 1 || !uuid(value.visit_id) || value.source_request_id !== request.source_request_id || !integer(value.credit_cost, 1) || !Array.isArray(value.bookings) || value.bookings.length !== request.appointments.length) return false
+  const bookingIds = new Set(), sessionIds = new Set()
+  let total = 0
+  for (const [index, booking] of value.bookings.entries()) {
+    const expected = request.appointments[index]
+    if (!selection(booking) || !uuid(booking.booking_id) || !uuid(booking.service_session_id) || !['confirmed', 'cancelled', 'attended', 'no_show'].includes(booking.status) || bookingIds.has(booking.booking_id) || sessionIds.has(booking.service_session_id) || booking.service_offering_id !== expected.service_offering_id || Date.parse(booking.starts_at) !== Date.parse(expected.starts_at) || Date.parse(booking.ends_at) !== Date.parse(expected.ends_at) || booking.credit_cost !== expected.credit_cost) return false
+    bookingIds.add(booking.booking_id); sessionIds.add(booking.service_session_id); total += booking.credit_cost
+  }
+  return total === value.credit_cost
+}
+const location = value => object(value) && /^[a-z]{8}$/u.test(value.public_id ?? '') && text(value.name, 160, 1) && text(value.timezone, 100, 1) && ['city', 'region'].every(key => value[key] === null || text(value[key], 4000))
+export function availabilityRange({ from, to }) {
+  check(timestamp(from) && timestamp(to) && Date.parse(to) > Date.parse(from) && Date.parse(to) - Date.parse(from) <= 14 * 86_400_000, 'Choose RFC 3339 timestamps spanning at most 14 days.')
+  return { from: new Date(from).toISOString(), to: new Date(to).toISOString() }
+}
+export function validAvailability(value, range) {
+  if (!object(value) || value.api_version !== 1 || !timestamp(value.generated_at) || !object(value.range) || value.range.from !== range.from || value.range.to !== range.to || typeof value.has_more !== 'boolean' || !Array.isArray(value.slots) || value.slots.length > 20_000) return false
+  const ids = new Set()
+  for (const slot of value.slots) {
+    if (!selection(slot) || !uuid(slot.service_id) || !integer(slot.duration_minutes, 1, 1440) || Date.parse(slot.ends_at) - Date.parse(slot.starts_at) !== slot.duration_minutes * 60_000 || !location(slot.location) || !object(slot.service) || slot.service.id !== slot.service_id || !text(slot.service.name, 160, 1) || !(slot.service.description === null || text(slot.service.description, 4000)) || slot.candidate_id !== `appointment:${slot.service_offering_id}:${slot.duration_minutes}:${Date.parse(slot.starts_at)}` || Date.parse(slot.starts_at) < Date.parse(range.from) || Date.parse(slot.starts_at) >= Date.parse(range.to) || ids.has(slot.candidate_id)) return false
+    ids.add(slot.candidate_id)
+  }
+  return true
+}
+export function validBookingCatalog(value) {
+  if (!object(value) || value.api_version !== 1 || !timestamp(value.generated_at) || !object(value.experience) || !['classes', 'appointments'].every(key => typeof value.experience[key] === 'boolean') || !['classes', 'appointments'].includes(value.experience.default_view) || !Array.isArray(value.locations) || value.locations.length > 1000 || !value.locations.every(location) || !Array.isArray(value.services) || value.services.length > 1000 || (value.cancellation_notice_minutes !== undefined && !integer(value.cancellation_notice_minutes, 0, 10080))) return false
+  const locations = new Set(value.locations.map(item => item.public_id)), services = new Set(), offerings = new Set()
+  if (locations.size !== value.locations.length || value.experience.appointments !== (value.services.length > 0) || (value.experience.classes || value.experience.appointments) && !value.experience[value.experience.default_view]) return false
+  for (const service of value.services) {
+    if (!object(service) || !uuid(service.id) || services.has(service.id) || !text(service.name, 160, 1) || !(service.description === null || text(service.description, 4000)) || !Array.isArray(service.offerings) || service.offerings.length < 1 || service.offerings.length > 1000) return false
+    services.add(service.id)
+    for (const offering of service.offerings) {
+      if (!object(offering) || !uuid(offering.id) || offerings.has(offering.id) || !integer(offering.duration_minutes, 1, 1440) || !locations.has(offering.location_public_id) || !(offering.credit_cost === null || integer(offering.credit_cost, 1, 100000))) return false
+      offerings.add(offering.id)
+    }
+  }
+  return true
+}
+export function accountInput({ mode, email, signupIntent }) {
+  check(['signup', 'recovery'].includes(mode) && typeof email === 'string' && email.trim().includes('@') && email.length <= 320 && !/[\u0000-\u001f\u007f]/u.test(email), 'Provide a valid account mode and email address.')
+  if (mode === 'signup') check(['new', 'migrate', 'auto', 'activate'].includes(signupIntent), 'Choose a signup intent explicitly.')
+}
+export function displayName(value) { check(text(value, 160, 1) && Boolean(value.trim()) && !/[\u0000-\u001f\u007f]/u.test(value), 'Provide a display name.'); return value }
+export function emailCode(value) { check(typeof value === 'string' && /^\d{6}$/u.test(value.trim()), 'Provide the six-digit email code.'); return value.trim() }
+export function validCapability(value) { return typeof value === 'string' && /^[A-Za-z0-9_-]{43}$/u.test(value) }
+export function accountResolution(value) {
+  check(object(value) && ['existing_account', 'existing_profile', 'new_profile'].includes(value.kind) && text(value.display_name, 160, 1) && Boolean(value.display_name.trim()) && !/[\u0000-\u001f\u007f]/u.test(value.display_name) && text(value.masked_email, 320) && /^[^@\s*]\*{3}@[^@\s*]\*{3}(?:\.[a-z0-9.-]+)?$/iu.test(value.masked_email) && (value.masked_phone === null || /^\*{3} \*{3} [0-9]{4}$/u.test(value.masked_phone ?? '')))
+  return { kind: value.kind, display_name: value.display_name, masked_email: value.masked_email, masked_phone: value.masked_phone }
+}

package/src/organization-contracts.generated.d.ts

@@ -0,0 +1,31 @@
+// Generated from reviewed API contracts. Run npm run api:generate; do not edit.
+export interface OrganizationReadInputs {
+  "organization.read": Record<string, never>
+  "locations.read": Record<string, never>
+  "services.read": Record<string, never>
+  "schedule.read": { "week"?: string; "month"?: string }
+  "users.directory.read": { "q"?: string; "limit"?: number; "offset"?: number; "facet"?: "all" | "customers"; "customer_status"?: "active" | "inactive" | "archived" }
+  "task_lists.read": Record<string, never>
+  "inventory.read": Record<string, never>
+}
+export interface OrganizationReadResults {
+  "organization.read": { "api_version": 1; "data": { "organization": { "id": string; "slug": string; "name": string; "timezone": string; "currency_code": string; "brand_name"?: (string | null); [key: string]: unknown }; "access": { [key: string]: unknown } } }
+  "locations.read": { "api_version": 1; "data": { "locations": Array<{ "id": string; "name": string; "timezone": string; "status": string; "formatted_address"?: (string | null); [key: string]: unknown }> } }
+  "services.read": { "api_version": 1; "data": { "services": Array<{ "id": string; "name": string; "description"?: (string | null); "duration_minutes": number; "default_capacity"?: (number | null); "status": "active" | "inactive"; [key: string]: unknown }>; "past_session_variations": Array<{ [key: string]: unknown }> } }
+  "schedule.read": { "api_version": 1; "data": { "week_start": string; "sessions": Array<{ [key: string]: unknown }>; "staffing_windows": Array<{ [key: string]: unknown }>; "staffing_load_error": (string | null); "calendar": { "month": string; "days": Array<{ [key: string]: unknown }>; [key: string]: unknown } } }
+  "users.directory.read": { "api_version": 1; "data": { "users": Array<{ "id": string; "display_name": (string | null); "email"?: (string | null); "phone_e164"?: (string | null); "is_customer"?: boolean; "is_staff"?: boolean; "has_workspace_access"?: boolean; "person_status"?: "active" | "archived"; "customer_status"?: ("active" | "inactive" | "archived" | null) }>; "filters": { "facet": "all" | "customers"; "customer_status": ("active" | "inactive" | "archived" | null) }; "pagination": { "total": number; "limit": number; "offset": number; "has_more": boolean; "query": string } } }
+  "task_lists.read": { "api_version": 1; "data": { "task_lists": Array<{ [key: string]: unknown }>; "locations": Array<{ [key: string]: unknown }>; "can_manage_organization": boolean; [key: string]: unknown } }
+  "inventory.read": { "api_version": 1; "data": { "inventory": { "locations": Array<{ [key: string]: unknown }>; "stocks": Array<{ [key: string]: unknown }>; "alerts": Array<{ [key: string]: unknown }>; "movements": Array<{ [key: string]: unknown }>; "currency_code": string; [key: string]: unknown } } }
+}
+export type OrganizationReadOperationId = keyof OrganizationReadInputs
+export interface OrganizationWriteInputs {
+  "messages.send": { "path"?: Record<string, never>; "body": { "channel_id": string; "body": string; "attachment_ids"?: Array<string>; "title"?: string; "preview"?: unknown; "action"?: unknown } }
+  "messages.read_state.update": { "path": { "channel_id": string }; "body": { "message_id": string } }
+  "messages.mute.update": { "path": { "channel_id": string }; "body": { "is_muted": boolean } }
+}
+export interface OrganizationWriteResults {
+  "messages.send": { "api_version": 1; "message": { "attachments"?: Array<{ "file_name": string; "content_type": "image/jpeg" | "image/png" | "image/webp" | "image/gif" | "image/heic" | "application/pdf" | "text/plain" | "text/csv" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/vnd.openxmlformats-officedocument.presentationml.presentation"; "byte_size": number; "id": string }>; "id": string; "body": string; "kind": "announcement" | "deleted" | "notification"; "notification": ({ "source_kind": "service_session_work_slot" | "service_session_provider" | "staffing_window_assignment" | "staffing_window"; "source_id": string; "session_id": (string | null); "session_starts_at": (string | null); "staffing_window_id": (string | null); "starts_at": string; "time_zone": string; "status": "open" | "claimed" | "withdrawn" | "cancelled"; "label": string } | null); "author_name": string; "is_mine": boolean; "created_at": string; "edited_at": (string | null); "deleted_at": (string | null) } }
+  "messages.read_state.update": { "api_version": 1; "state": { "channel_id": string; "message_id": string; "read_at": string } }
+  "messages.mute.update": { "api_version": 1; "state": { "channel_id": string; "is_muted": boolean } }
+}
+export type OrganizationWriteOperationId = keyof OrganizationWriteInputs