SDK methods · StartupBuilder

Every Verb on every Noun as a typed method of $, the client in the startup-builder package.

Grammar

TypeScript

import { $ } from 'startup-builder'

await $.Noun.verb(input)          // the result
await $.send.Noun.verb(input)     // a pending Action
await $.Noun.verb(input).settled  // the Action, in any final status

The SDK spec covers authentication, Modes, and errors.

Access Level

Operation	Call	Resolves to
AccessLevel.get	`await $.AccessLevel.get({ id: 'access_level_1' })`	Access Level
AccessLevel.list	`await $.AccessLevel.list({ limit: 20 })`	list of Access Level

Account

Operation	Call	Resolves to
Account.get	`await $.Account.get({ id: 'account_1' })`	Account
Account.list	`await $.Account.list({ limit: 20 })`	list of Account
Account.payout	`await $.Account.payout({ account: 'account_1' })`	`account`: Account, `transaction`: Transaction
Account.sweep	`await $.Account.sweep({ from: 'account_1', to: 'account_1' })`	`account`: Account, `transaction`: Transaction

Acquisition

Operation	Call	Resolves to
Acquisition.get	`await $.Acquisition.get({ id: 'acquisition_1' })`	Acquisition
Acquisition.list	`await $.Acquisition.list({ limit: 20 })`	list of Acquisition

Action

Operation	Call	Resolves to
Action.create	`await $.Action.create({ by: 'worker_1' })`	Action
Action.get	`await $.Action.get({ id: 'action_1' })`	Action
Action.list	`await $.Action.list({ limit: 20 })`	list of Action
Action.answer	`await $.Action.answer({ action: 'action_1', question: 'question_1', payload: {} })`	Action
Action.ask	`await $.Action.ask({ action: 'action_1', to: 'thing_1', text: 'Example text' })`	`question`: Question, `action`: Action
Action.attest	`await $.Action.attest({ action: 'action_1', credential: 'credential_1' })`	Action
Action.cancel	`await $.Action.cancel({ action: 'action_1' })`	Action
Action.evaluate	`await $.Action.evaluate({ action: 'action_1', evaluator: 'Example evaluator' })`	`verdict`: `json`, `action`: Action
Action.pause	`await $.Action.pause({ action: 'action_1', reason: 'Example reason' })`	Action
Action.redirect	`await $.Action.redirect({ action: 'action_1', changes: {} })`	Action
Action.resume	`await $.Action.resume({ action: 'action_1', reason: 'Example reason' })`	Action
Action.retry	`await $.Action.retry({ action: 'action_1' })`	Action

Operation	Call	Resolves to
Ad.create	`await $.Ad.create({ format: 'search' })`	Ad
Ad.get	`await $.Ad.get({ id: 'ad_1' })`	Ad
Ad.list	`await $.Ad.list({ limit: 20 })`	list of Ad
Ad.update	`await $.Ad.update({ id: 'ad_1', format: 'search' })`	Ad
Ad.delete	`await $.Ad.delete({ id: 'ad_1' })`	Ad

Agent

Operation	Call	Resolves to
Agent.create	`await $.Agent.create({ instructions: 'Example instructions', model: 'Example model' })`	Agent
Agent.get	`await $.Agent.get({ id: 'agent_1' })`	Agent
Agent.list	`await $.Agent.list({ limit: 20 })`	list of Agent
Agent.update	`await $.Agent.update({ id: 'agent_1', skills: ['skill_1'] })`	Agent
Agent.delete	`await $.Agent.delete({ id: 'agent_1' })`	Agent
Agent.mint	`await $.Agent.mint({ tenant: 'tenant_1', product: 'product_1' })`	Agent
Agent.pause	`await $.Agent.pause({ agents: ['agent_1'], reason: 'Example reason' })`	list of Agent
Agent.resume	`await $.Agent.resume({ agent: 'agent_1' })`	Agent
Agent.retire	`await $.Agent.retire({ agent: 'agent_1', reason: 'Example reason' })`	Agent

Agreement

Operation	Call	Resolves to
Agreement.create	`await $.Agreement.create({ term: 'Example term' })`	Agreement
Agreement.get	`await $.Agreement.get({ id: 'agreement_1' })`	Agreement
Agreement.list	`await $.Agreement.list({ limit: 20 })`	list of Agreement
Agreement.update	`await $.Agreement.update({ id: 'agreement_1', signedAt: '2026-10-22T12:00:00Z' })`	Agreement
Agreement.sign	`await $.Agreement.sign({ agreement: 'agreement_1' })`	Agreement
Agreement.terminate	`await $.Agreement.terminate({ agreement: 'agreement_1', reason: 'Example reason' })`	Agreement

API Key

Operation	Call	Resolves to
APIKey.get	`await $.APIKey.get({ id: 'api_key_1' })`	API Key
APIKey.list	`await $.APIKey.list({ limit: 20 })`	list of API Key
APIKey.issue	`await $.APIKey.issue({ customer: 'customer_1', name: 'Nightly sync', environment: 'test' })`	`apiKey`: API Key, `secret`: `string`
APIKey.revoke	`await $.APIKey.revoke({ apiKey: 'api_key_1' })`	API Key
APIKey.roll	`await $.APIKey.roll({ apiKey: 'api_key_1' })`	`apiKey`: API Key, `secret`: `string`

App

Operation	Call	Resolves to
App.publish	`await $.App.publish({ app: 'app_1' })`	App

Approval

Operation	Call	Resolves to
Approval.create	`await $.Approval.create({ by: 'worker_1' })`	Approval
Approval.get	`await $.Approval.get({ id: 'approval_1' })`	Approval
Approval.list	`await $.Approval.list({ limit: 20 })`	list of Approval
Approval.update	`await $.Approval.update({ id: 'approval_1', verdict: 'allowed' })`	Approval
Approval.delete	`await $.Approval.delete({ id: 'approval_1' })`	Approval
Approval.approve	`await $.Approval.approve({ approval: 'approval_1' })`	Approval
Approval.refuse	`await $.Approval.refuse({ approval: 'approval_1', reason: 'Example reason' })`	Approval

Attestation

Operation	Call	Resolves to
Attestation.create	`await $.Attestation.create({ outcome: 'performed', signedAt: '2026-10-22T12:00:00Z' })`	Attestation
Attestation.get	`await $.Attestation.get({ id: 'attestation_1' })`	Attestation
Attestation.list	`await $.Attestation.list({ limit: 20 })`	list of Attestation

Audience

Operation	Call	Resolves to
Audience.create	`await $.Audience.create({ id: 'audience_1', type: ['noun_1'] })`	Audience
Audience.get	`await $.Audience.get({ id: 'audience_1' })`	Audience
Audience.list	`await $.Audience.list({ limit: 20 })`	list of Audience
Audience.update	`await $.Audience.update({ id: 'audience_1', size: 1 })`	Audience
Audience.delete	`await $.Audience.delete({ id: 'audience_1' })`	Audience

Audit

Operation	Call	Resolves to
Audit.get	`await $.Audit.get({ id: 'audit_1' })`	Audit
Audit.list	`await $.Audit.list({ limit: 20 })`	list of Audit

Bill

Operation	Call	Resolves to
Bill.create	`await $.Bill.create({ organization: 'organization_1', amount: { amount: 49, currency: 'USD' }, dueOn: '2026-10-22' })`	Bill
Bill.get	`await $.Bill.get({ id: 'bill_1' })`	Bill
Bill.list	`await $.Bill.list({ limit: 20 })`	list of Bill
Bill.update	`await $.Bill.update({ id: 'bill_1', organization: 'organization_1' })`	Bill
Bill.approve	`await $.Bill.approve({ bill: 'bill_1' })`	Bill
Bill.pay	`await $.Bill.pay({ bill: 'bill_1' })`	`transaction`: Transaction, `bill`: Bill

Brand

Operation	Call	Resolves to
Brand.create	`await $.Brand.create({ name: 'Acme' })`	Brand
Brand.get	`await $.Brand.get({ id: 'brand_1' })`	Brand
Brand.list	`await $.Brand.list({ limit: 20 })`	list of Brand
Brand.update	`await $.Brand.update({ id: 'brand_1', name: 'Acme' })`	Brand
Brand.delete	`await $.Brand.delete({ id: 'brand_1' })`	Brand
Brand.clear	`await $.Brand.clear({ brand: 'brand_1' })`	`verdict`: `string`, `findings`: `json`, `brand`: Brand

Budget

Operation	Call	Resolves to
Budget.create	`await $.Budget.create({ account: 'expense.ads', period: 'period_1', amount: { amount: 49, currency: 'USD' } })`	Budget
Budget.get	`await $.Budget.get({ id: 'budget_1' })`	Budget
Budget.list	`await $.Budget.list({ limit: 20 })`	list of Budget
Budget.update	`await $.Budget.update({ id: 'budget_1', account: 'expense.ads' })`	Budget
Budget.delete	`await $.Budget.delete({ id: 'budget_1' })`	Budget

Builder

Operation	Call	Resolves to
Builder.get	`await $.Builder.get({ id: 'builder_1' })`	Builder
Builder.list	`await $.Builder.list({ limit: 20 })`	list of Builder

Campaign

Operation	Call	Resolves to
Campaign.create	`await $.Campaign.create({ budget: { amount: 49, currency: 'USD' } })`	Campaign
Campaign.get	`await $.Campaign.get({ id: 'campaign_1' })`	Campaign
Campaign.list	`await $.Campaign.list({ limit: 20 })`	list of Campaign
Campaign.update	`await $.Campaign.update({ id: 'campaign_1', budget: { amount: 49, currency: 'USD' } })`	Campaign
Campaign.delete	`await $.Campaign.delete({ id: 'campaign_1' })`	Campaign

Candidate

Operation	Call	Resolves to
Candidate.create	`await $.Candidate.create({ opening: 'opening_1', person: 'person_1', source: 'pool' })`	Candidate
Candidate.get	`await $.Candidate.get({ id: 'candidate_1' })`	Candidate
Candidate.list	`await $.Candidate.list({ limit: 20 })`	list of Candidate
Candidate.update	`await $.Candidate.update({ id: 'candidate_1', opening: 'opening_1' })`	Candidate
Candidate.delete	`await $.Candidate.delete({ id: 'candidate_1' })`	Candidate
Candidate.screen	`await $.Candidate.screen({ candidate: 'candidate_1' })`	Candidate

Capability

Operation	Call	Resolves to
Capability.get	`await $.Capability.get({ id: 'capability_1' })`	Capability
Capability.list	`await $.Capability.list({ limit: 20 })`	list of Capability

Capital Call

Operation	Call	Resolves to
CapitalCall.get	`await $.CapitalCall.get({ id: 'capital_call_1' })`	Capital Call
CapitalCall.list	`await $.CapitalCall.list({ limit: 20 })`	list of Capital Call

Capital Commitment

Operation	Call	Resolves to
CapitalCommitment.create	`await $.CapitalCommitment.create({ investor: 'party_1', amount: { amount: 49, currency: 'USD' } })`	Capital Commitment
CapitalCommitment.get	`await $.CapitalCommitment.get({ id: 'capital_commitment_1' })`	Capital Commitment
CapitalCommitment.list	`await $.CapitalCommitment.list({ limit: 20 })`	list of Capital Commitment
CapitalCommitment.update	`await $.CapitalCommitment.update({ id: 'capital_commitment_1', investor: 'party_1' })`	Capital Commitment
CapitalCommitment.countersign	`await $.CapitalCommitment.countersign({ commitment: 'capital_commitment_1', agreement: 'agreement_1' })`	Capital Commitment

Card

Operation	Call	Resolves to
Card.get	`await $.Card.get({ id: 'card_1' })`	Card
Card.list	`await $.Card.list({ limit: 20 })`	list of Card
Card.issue	`await $.Card.issue({ mandate: 'mandate_1', form: 'singleUse' })`	Card

Change

Operation	Call	Resolves to
Change.create	`await $.Change.create({ base: 'version_1' })`	Change
Change.get	`await $.Change.get({ id: 'change_1' })`	Change
Change.list	`await $.Change.list({ limit: 20 })`	list of Change
Change.merge	`await $.Change.merge({ change: 'change_1' })`	`version`: Version, `change`: Change
Change.revert	`await $.Change.revert({ change: 'change_1', reason: 'Example reason' })`	Change
Change.review	`await $.Change.review({ change: 'change_1' })`	Change

Channel

Operation	Call	Resolves to
Channel.create	`await $.Channel.create({ medium: 'email' })`	Channel
Channel.get	`await $.Channel.get({ id: 'channel_1' })`	Channel
Channel.list	`await $.Channel.list({ limit: 20 })`	list of Channel
Channel.update	`await $.Channel.update({ id: 'channel_1', medium: 'email' })`	Channel
Channel.delete	`await $.Channel.delete({ id: 'channel_1' })`	Channel

Cohort

Operation	Call	Resolves to
Cohort.create	`await $.Cohort.create({ query: {} })`	Cohort
Cohort.get	`await $.Cohort.get({ id: 'cohort_1' })`	Cohort
Cohort.list	`await $.Cohort.list({ limit: 20 })`	list of Cohort
Cohort.update	`await $.Cohort.update({ id: 'cohort_1', query: {} })`	Cohort
Cohort.delete	`await $.Cohort.delete({ id: 'cohort_1' })`	Cohort

Collection

Operation	Call	Resolves to
Collection.create	`await $.Collection.create({ id: 'collection_1', type: ['noun_1'] })`	Collection
Collection.get	`await $.Collection.get({ id: 'collection_1' })`	Collection
Collection.list	`await $.Collection.list({ limit: 20 })`	list of Collection
Collection.update	`await $.Collection.update({ id: 'collection_1', query: {} })`	Collection
Collection.delete	`await $.Collection.delete({ id: 'collection_1' })`	Collection
Collection.export	`await $.Collection.export({ collection: 'collection_1', to: 'Example to' })`	`file`: File, `collection`: Collection
Collection.query	`await $.Collection.query({ query: 'Example query' })`	`rows`: `json`, `collection`: Collection

Comment

Operation	Call	Resolves to
Comment.create	`await $.Comment.create({ body: 'Example body' })`	Comment
Comment.get	`await $.Comment.get({ id: 'comment_1' })`	Comment
Comment.list	`await $.Comment.list({ limit: 20 })`	list of Comment
Comment.update	`await $.Comment.update({ id: 'comment_1', body: 'Example body' })`	Comment
Comment.delete	`await $.Comment.delete({ id: 'comment_1' })`	Comment

Commission

Operation	Call	Resolves to
Commission.create	`await $.Commission.create({ rate: 1, term: 1, clawbackDays: 1 })`	Commission
Commission.get	`await $.Commission.get({ id: 'commission_1' })`	Commission
Commission.list	`await $.Commission.list({ limit: 20 })`	list of Commission
Commission.update	`await $.Commission.update({ id: 'commission_1', rate: 1 })`	Commission
Commission.pay	`await $.Commission.pay({ commission: 'commission_1' })`	`commission`: Commission, `transaction`: Transaction

Company

Operation	Call	Resolves to
Company.create	`await $.Company.create({ name: 'Acme', legalName: 'Acme Inc.', jurisdiction: 'US-DE' })`	Company
Company.get	`await $.Company.get({ id: 'company_1' })`	Company
Company.list	`await $.Company.list({ limit: 20 })`	list of Company
Company.update	`await $.Company.update({ id: 'company_1', legalName: 'Acme Inc.' })`	Company
Company.dissolve	`await $.Company.dissolve({ company: 'company_1', reason: 'Example reason' })`	Company
Company.incorporate	`await $.Company.incorporate({ legalName: 'Acme Inc.', jurisdiction: 'US-DE' })`	Company
Company.register	`await $.Company.register({ jurisdiction: 'US-TX', kind: 'salesTax' })`	`credential`: Credential, `company`: Company
Company.submit	`await $.Company.submit({ jurisdiction: 'US-TX', kind: 'salesTax', periods: ['period_1'] })`	`taxReturn`: Document, `payment`: Transaction, `company`: Company

Component

Operation	Call	Resolves to
Component.create	`await $.Component.create({ name: 'Acme', props: {} })`	Component
Component.get	`await $.Component.get({ id: 'component_1' })`	Component
Component.list	`await $.Component.list({ limit: 20 })`	list of Component
Component.update	`await $.Component.update({ id: 'component_1', name: 'Acme' })`	Component
Component.delete	`await $.Component.delete({ id: 'component_1' })`	Component

Operation	Call	Resolves to
Consent.create	`await $.Consent.create({ basis: 'Example basis' })`	Consent
Consent.get	`await $.Consent.get({ id: 'consent_1' })`	Consent
Consent.list	`await $.Consent.list({ limit: 20 })`	list of Consent
Consent.update	`await $.Consent.update({ id: 'consent_1', withdrawnAt: '2026-10-22T12:00:00Z' })`	Consent
Consent.withdraw	`await $.Consent.withdraw({ consent: 'consent_1' })`	Consent

Contact

Operation	Call	Resolves to
Contact.create	`await $.Contact.create({ email: 'ada@acme.com' })`	Contact
Contact.get	`await $.Contact.get({ id: 'contact_1' })`	Contact
Contact.list	`await $.Contact.list({ limit: 20 })`	list of Contact
Contact.update	`await $.Contact.update({ id: 'contact_1', email: 'ada@acme.com' })`	Contact
Contact.delete	`await $.Contact.delete({ id: 'contact_1' })`	Contact
Contact.enrich	`await $.Contact.enrich({ contact: 'contact_1' })`	Contact
Contact.enroll	`await $.Contact.enroll({ contact: 'contact_1', sequence: 'sequence_1' })`	`contact`: Contact, `enrollment`: Enrollment
Contact.merge	`await $.Contact.merge({ contact: 'contact_1', into: 'contact_1' })`	Contact
Contact.subscribe	`await $.Contact.subscribe({ contact: 'contact_1', topics: ['Example topics'] })`	Contact
Contact.suppress	`await $.Contact.suppress({ contact: 'contact_1' })`	Contact
Contact.unsubscribe	`await $.Contact.unsubscribe({ contact: 'contact_1' })`	Contact

Content

Operation	Call	Resolves to
Content.create	`await $.Content.create({ title: 'Acme API' })`	Content
Content.get	`await $.Content.get({ id: 'content_1' })`	Content
Content.list	`await $.Content.list({ limit: 20 })`	list of Content
Content.update	`await $.Content.update({ id: 'content_1', title: 'Acme API' })`	Content
Content.delete	`await $.Content.delete({ id: 'content_1' })`	Content
Content.draft	`await $.Content.draft({ kind: 'article', brief: 'Example brief' })`	Content
Content.publish	`await $.Content.publish({ content: 'content_1' })`	Content

Control

Operation	Call	Resolves to
Control.get	`await $.Control.get({ id: 'control_1' })`	Control
Control.list	`await $.Control.list({ limit: 20 })`	list of Control

Conversation

Operation	Call	Resolves to
Conversation.create	`await $.Conversation.create({ subject: 'Example subject' })`	Conversation
Conversation.get	`await $.Conversation.get({ id: 'conversation_1' })`	Conversation
Conversation.list	`await $.Conversation.list({ limit: 20 })`	list of Conversation
Conversation.update	`await $.Conversation.update({ id: 'conversation_1', answeredAt: '2026-10-22T12:00:00Z' })`	Conversation
Conversation.delete	`await $.Conversation.delete({ id: 'conversation_1' })`	Conversation
Conversation.answer	`await $.Conversation.answer({ conversation: 'conversation_1', body: 'Example body' })`	Conversation
Conversation.assign	`await $.Conversation.assign({ conversation: 'conversation_1' })`	Conversation
Conversation.close	`await $.Conversation.close({ conversation: 'conversation_1', resolution: 'confirmed' })`	Conversation
Conversation.escalate	`await $.Conversation.escalate({ conversation: 'conversation_1', reason: 'lowConfidence' })`	Conversation
Conversation.reopen	`await $.Conversation.reopen({ conversation: 'conversation_1', signal: 'askedForPerson' })`	Conversation

Cost

Operation	Call	Resolves to
Cost.get	`await $.Cost.get({ id: 'cost_1' })`	Cost
Cost.list	`await $.Cost.list({ limit: 20 })`	list of Cost

Coupon

Operation	Call	Resolves to
Coupon.create	`await $.Coupon.create({ duration: 'once' })`	Coupon
Coupon.get	`await $.Coupon.get({ id: 'coupon_1' })`	Coupon
Coupon.list	`await $.Coupon.list({ limit: 20 })`	list of Coupon
Coupon.update	`await $.Coupon.update({ id: 'coupon_1', percentOff: 1 })`	Coupon

Credential

Operation	Call	Resolves to
Credential.create	`await $.Credential.create({ issuer: 'Example issuer', jurisdiction: 'US-DE' })`	Credential
Credential.get	`await $.Credential.get({ id: 'credential_1' })`	Credential
Credential.list	`await $.Credential.list({ limit: 20 })`	list of Credential
Credential.update	`await $.Credential.update({ id: 'credential_1', jurisdiction: 'US-DE' })`	Credential
Credential.delete	`await $.Credential.delete({ id: 'credential_1' })`	Credential
Credential.verify	`await $.Credential.verify({ credential: 'credential_1' })`	Credential

Credit Grant

Operation	Call	Resolves to
CreditGrant.create	`await $.CreditGrant.create({ amount: { amount: 49, currency: 'USD' }, category: 'paid' })`	Credit Grant
CreditGrant.get	`await $.CreditGrant.get({ id: 'credit_grant_1' })`	Credit Grant
CreditGrant.list	`await $.CreditGrant.list({ limit: 20 })`	list of Credit Grant
CreditGrant.apply	`await $.CreditGrant.apply({ invoice: 'invoice_1' })`	`applied`: `money`, `creditGrants`: list of Credit Grant
CreditGrant.issue	`await $.CreditGrant.issue({ customer: 'customer_1', amount: { amount: 49, currency: 'USD' }, category: 'paid' })`	Credit Grant
CreditGrant.void	`await $.CreditGrant.void({ creditGrant: 'credit_grant_1', reason: 'Example reason' })`	Credit Grant

Criterion

Operation	Call	Resolves to
Criterion.get	`await $.Criterion.get({ id: 'criterion_1' })`	Criterion
Criterion.list	`await $.Criterion.list({ limit: 20 })`	list of Criterion

Customer

Operation	Call	Resolves to
Customer.create	`await $.Customer.create({ since: '2026-10-22T12:00:00Z' })`	Customer
Customer.get	`await $.Customer.get({ id: 'customer_1' })`	Customer
Customer.list	`await $.Customer.list({ limit: 20 })`	list of Customer
Customer.update	`await $.Customer.update({ id: 'customer_1', since: '2026-10-22T12:00:00Z' })`	Customer
Customer.delete	`await $.Customer.delete({ id: 'customer_1' })`	Customer
Customer.activate	`await $.Customer.activate({ customer: 'customer_1', offer: 'offer_1' })`	Customer
Customer.exempt	`await $.Customer.exempt({ customer: 'customer_1', certificate: 'file_1', jurisdictions: ['US-TX'] })`	`credential`: Credential, `customer`: Customer

Dashboard

Operation	Call	Resolves to
Dashboard.create	`await $.Dashboard.create({ scope: 'Startup' })`	Dashboard
Dashboard.get	`await $.Dashboard.get({ id: 'dashboard_1' })`	Dashboard
Dashboard.list	`await $.Dashboard.list({ limit: 20 })`	list of Dashboard
Dashboard.update	`await $.Dashboard.update({ id: 'dashboard_1', scope: 'Startup' })`	Dashboard
Dashboard.delete	`await $.Dashboard.delete({ id: 'dashboard_1' })`	Dashboard
Dashboard.ask	`await $.Dashboard.ask({ question: 'Example question' })`	`query`: `text`, `rows`: `json`, `dashboard`: Dashboard
Dashboard.schedule	`await $.Dashboard.schedule({ dashboard: 'dashboard_1', cadence: 'daily', to: 'Example to' })`	Dashboard

Dataset

Operation	Call	Resolves to
Dataset.create	`await $.Dataset.create({ name: 'Acme', promise: 'A first draft within one day.' })`	Dataset
Dataset.get	`await $.Dataset.get({ id: 'dataset_1' })`	Dataset
Dataset.list	`await $.Dataset.list({ limit: 20 })`	list of Dataset
Dataset.update	`await $.Dataset.update({ id: 'dataset_1', records: 1 })`	Dataset
Dataset.delete	`await $.Dataset.delete({ id: 'dataset_1' })`	Dataset

Deal

Operation	Call	Resolves to
Deal.create	`await $.Deal.create({ value: { amount: 49, currency: 'USD' } })`	Deal
Deal.get	`await $.Deal.get({ id: 'deal_1' })`	Deal
Deal.list	`await $.Deal.list({ limit: 20 })`	list of Deal
Deal.update	`await $.Deal.update({ id: 'deal_1', value: { amount: 49, currency: 'USD' } })`	Deal
Deal.delete	`await $.Deal.delete({ id: 'deal_1' })`	Deal
Deal.advance	`await $.Deal.advance({ deal: 'deal_1' })`	Deal
Deal.assign	`await $.Deal.assign({ deal: 'deal_1' })`	Deal
Deal.lose	`await $.Deal.lose({ deal: 'deal_1', reason: 'Example reason' })`	Deal
Deal.propose	`await $.Deal.propose({ deal: 'deal_1', quote: 'quote_1' })`	Deal
Deal.win	`await $.Deal.win({ deal: 'deal_1' })`	`order`: Order, `deal`: Deal

Decision

Operation	Call	Resolves to
Decision.create	`await $.Decision.create({ choice: 'Example choice', reason: 'Example reason' })`	Decision
Decision.get	`await $.Decision.get({ id: 'decision_1' })`	Decision
Decision.list	`await $.Decision.list({ limit: 20 })`	list of Decision
Decision.supersede	`await $.Decision.supersede({ decision: 'decision_1', by: 'decision_1' })`	Decision

Demand Budget

Operation	Call	Resolves to
DemandBudget.create	`await $.DemandBudget.create({ amount: { amount: 49, currency: 'USD' }, tier: '$0', target: 'Example target', stopRule: 'Example stop rule' })`	Demand Budget
DemandBudget.get	`await $.DemandBudget.get({ id: 'demand_budget_1' })`	Demand Budget
DemandBudget.list	`await $.DemandBudget.list({ limit: 20 })`	list of Demand Budget
DemandBudget.update	`await $.DemandBudget.update({ id: 'demand_budget_1', amount: { amount: 49, currency: 'USD' } })`	Demand Budget

Dispute

Operation	Call	Resolves to
Dispute.get	`await $.Dispute.get({ id: 'dispute_1' })`	Dispute
Dispute.list	`await $.Dispute.list({ limit: 20 })`	list of Dispute
Dispute.accept	`await $.Dispute.accept({ dispute: 'dispute_1', reason: 'Example reason' })`	Dispute
Dispute.answer	`await $.Dispute.answer({ dispute: 'dispute_1', evidence: ['evidence_1'] })`	Dispute
Dispute.appeal	`await $.Dispute.appeal({ dispute: 'dispute_1', reason: 'Example reason' })`	Dispute
Dispute.decide	`await $.Dispute.decide({ dispute: 'dispute_1', decision: 'buyer', reason: 'Example reason' })`	Dispute

DNS Record

Operation	Call	Resolves to
DNSRecord.get	`await $.DNSRecord.get({ id: 'dns_record_1' })`	DNS Record
DNSRecord.list	`await $.DNSRecord.list({ limit: 20 })`	list of DNS Record
DNSRecord.remove	`await $.DNSRecord.remove({ record: 'dns_record_1' })`	DNS Record
DNSRecord.set	`await $.DNSRecord.set({ domain: 'domain_1', type: 'a', name: 'Acme', value: 'Example value' })`	DNS Record

Document

Operation	Call	Resolves to
Document.create	`await $.Document.create({ form: 'document' })`	Document
Document.get	`await $.Document.get({ id: 'document_1' })`	Document
Document.list	`await $.Document.list({ limit: 20 })`	list of Document
Document.update	`await $.Document.update({ id: 'document_1', form: 'document' })`	Document
Document.delete	`await $.Document.delete({ id: 'document_1' })`	Document
Document.render	`await $.Document.render({ document: 'document_1', format: 'Example format' })`	`file`: `url`, `document`: Document

Domain

Operation	Call	Resolves to
Domain.create	`await $.Domain.create({ hostname: 'acme.com', role: 'canonical' })`	Domain
Domain.get	`await $.Domain.get({ id: 'domain_1' })`	Domain
Domain.list	`await $.Domain.list({ limit: 20 })`	list of Domain
Domain.update	`await $.Domain.update({ id: 'domain_1', hostname: 'acme.com' })`	Domain
Domain.delete	`await $.Domain.delete({ id: 'domain_1' })`	Domain
Domain.authenticate	`await $.Domain.authenticate({ domain: 'domain_1' })`	Domain
Domain.benchmark	`await $.Domain.benchmark({ hostname: 'taxcalc.tools' })`	`readings`: `json`, `domain`: Domain
Domain.claim	`await $.Domain.claim({ hostname: 'acme.headless.ly', startup: 'startup_1' })`	Domain
Domain.connect	`await $.Domain.connect({ hostname: 'acme.com', startup: 'startup_1' })`	Domain
Domain.register	`await $.Domain.register({ hostname: 'acme.com', startup: 'startup_1' })`	Domain
Domain.release	`await $.Domain.release({ domain: 'domain_1', reason: 'Example reason' })`	Domain
Domain.renew	`await $.Domain.renew({ domain: 'domain_1' })`	Domain
Domain.search	`await $.Domain.search({ query: 'Example query' })`	list of Domain
Domain.transfer	`await $.Domain.transfer({ domain: 'domain_1', to: 'Example to', kind: 'in' })`	Domain
Domain.verify	`await $.Domain.verify({ domain: 'domain_1' })`	`checks`: `json`, `domain`: Domain

Enrollment

Operation	Call	Resolves to
Enrollment.create	`await $.Enrollment.create({ step: 'Example step' })`	Enrollment
Enrollment.get	`await $.Enrollment.get({ id: 'enrollment_1' })`	Enrollment
Enrollment.list	`await $.Enrollment.list({ limit: 20 })`	list of Enrollment
Enrollment.update	`await $.Enrollment.update({ id: 'enrollment_1', nextAt: '2026-10-22T12:00:00Z' })`	Enrollment
Enrollment.delete	`await $.Enrollment.delete({ id: 'enrollment_1' })`	Enrollment
Enrollment.cancel	`await $.Enrollment.cancel({ enrollment: 'enrollment_1', reason: 'replied' })`	Enrollment
Enrollment.pause	`await $.Enrollment.pause({ enrollment: 'enrollment_1' })`	Enrollment
Enrollment.resume	`await $.Enrollment.resume({ enrollment: 'enrollment_1' })`	Enrollment

Entitlement

Operation	Call	Resolves to
Entitlement.create	`await $.Entitlement.create({ verb: 'verb_1' })`	Entitlement
Entitlement.get	`await $.Entitlement.get({ id: 'entitlement_1' })`	Entitlement
Entitlement.list	`await $.Entitlement.list({ limit: 20 })`	list of Entitlement
Entitlement.update	`await $.Entitlement.update({ id: 'entitlement_1', verb: 'verb_1' })`	Entitlement
Entitlement.delete	`await $.Entitlement.delete({ id: 'entitlement_1' })`	Entitlement
Entitlement.check	`await $.Entitlement.check({ customer: 'customer_1', verb: 'verb_1' })`	`allowed`: `boolean`, `entitlement`: Entitlement, `remaining`: `integer`, `resetsAt`: `datetime`, `upgrade`: Offer

Entry

Operation	Call	Resolves to
Entry.get	`await $.Entry.get({ id: 'entry_1' })`	Entry
Entry.list	`await $.Entry.list({ limit: 20 })`	list of Entry
Entry.post	`await $.Entry.post({ debit: 'Example debit', credit: 'Example credit', amount: { amount: 49, currency: 'USD' }, memo: 'Example memo' })`	Entry
Entry.settle	`await $.Entry.settle({ period: 'period_1', from: 'company_1', to: 'company_1' })`	`transaction`: Transaction, `entry`: Entry

Evaluator

Operation	Call	Resolves to
Evaluator.create	`await $.Evaluator.create({ kind: 'code', rubric: 'Example rubric' })`	Evaluator
Evaluator.get	`await $.Evaluator.get({ id: 'evaluator_1' })`	Evaluator
Evaluator.list	`await $.Evaluator.list({ limit: 20 })`	list of Evaluator
Evaluator.update	`await $.Evaluator.update({ id: 'evaluator_1', integration: 'integration_1' })`	Evaluator
Evaluator.delete	`await $.Evaluator.delete({ id: 'evaluator_1' })`	Evaluator

Event

Operation	Call	Resolves to
Event.create	`await $.Event.create({ name: 'Acme', at: '2026-10-22T12:00:00Z' })`	Event
Event.get	`await $.Event.get({ id: 'event_1' })`	Event
Event.list	`await $.Event.list({ limit: 20 })`	list of Event
Event.capture	`await $.Event.capture({ name: 'Acme' })`	Event

Evidence

Operation	Call	Resolves to
Evidence.create	`await $.Evidence.create({ grade: 'Behavior' })`	Evidence
Evidence.get	`await $.Evidence.get({ id: 'evidence_1' })`	Evidence
Evidence.list	`await $.Evidence.list({ limit: 20 })`	list of Evidence

Experiment

Operation	Call	Resolves to
Experiment.create	`await $.Experiment.create({ variants: {} })`	Experiment
Experiment.get	`await $.Experiment.get({ id: 'experiment_1' })`	Experiment
Experiment.list	`await $.Experiment.list({ limit: 20 })`	list of Experiment
Experiment.conclude	`await $.Experiment.conclude({ experiment: 'experiment_1', decision: 'ship' })`	`decision`: Decision, `experiment`: Experiment
Experiment.start	`await $.Experiment.start({ experiment: 'experiment_1' })`	Experiment

Exposure

Operation	Call	Resolves to
Exposure.create	`await $.Exposure.create({ unit: 'Example unit', options: {}, propensity: 1, at: '2026-10-22T12:00:00Z' })`	Exposure
Exposure.get	`await $.Exposure.get({ id: 'exposure_1' })`	Exposure
Exposure.list	`await $.Exposure.list({ limit: 20 })`	list of Exposure

File

Operation	Call	Resolves to
File.create	`await $.File.create({ contentType: 'Example content type', size: 1 })`	File
File.get	`await $.File.get({ id: 'file_1' })`	File
File.list	`await $.File.list({ limit: 20 })`	list of File
File.update	`await $.File.update({ id: 'file_1', size: 1 })`	File
File.delete	`await $.File.delete({ id: 'file_1' })`	File
File.edit	`await $.File.edit({ file: 'file_1', instruction: 'Example instruction' })`	File
File.generate	`await $.File.generate({ kind: 'image', prompt: 'Example prompt' })`	File

Flag

Operation	Call	Resolves to
Flag.create	`await $.Flag.create({ key: 'new-checkout' })`	Flag
Flag.get	`await $.Flag.get({ id: 'flag_1' })`	Flag
Flag.list	`await $.Flag.list({ limit: 20 })`	list of Flag
Flag.update	`await $.Flag.update({ id: 'flag_1', key: 'new-checkout' })`	Flag
Flag.delete	`await $.Flag.delete({ id: 'flag_1' })`	Flag
Flag.evaluate	`await $.Flag.evaluate({ flag: 'flag_1', unit: 'Example unit' })`	`variant`: Variant, `exposure`: Exposure

Flow

Operation	Call	Resolves to
Flow.create	`await $.Flow.create({ persona: 'persona_1', offer: 'offer_1', steps: ['dashboard_1'] })`	Flow
Flow.get	`await $.Flow.get({ id: 'flow_1' })`	Flow
Flow.list	`await $.Flow.list({ limit: 20 })`	list of Flow
Flow.update	`await $.Flow.update({ id: 'flow_1', persona: 'persona_1' })`	Flow
Flow.delete	`await $.Flow.delete({ id: 'flow_1' })`	Flow

Forecast

Operation	Call	Resolves to
Forecast.create	`await $.Forecast.create({ asOf: '2026-10-22T12:00:00Z', runwayWeeks: 1, defaultAlive: true, spendState: 'free' })`	Forecast
Forecast.get	`await $.Forecast.get({ id: 'forecast_1' })`	Forecast
Forecast.list	`await $.Forecast.list({ limit: 20 })`	list of Forecast

Form

Operation	Call	Resolves to
Form.create	`await $.Form.create({ fields: {} })`	Form
Form.get	`await $.Form.get({ id: 'form_1' })`	Form
Form.list	`await $.Form.list({ limit: 20 })`	list of Form
Form.update	`await $.Form.update({ id: 'form_1', fields: {} })`	Form
Form.delete	`await $.Form.delete({ id: 'form_1' })`	Form

Function

Operation	Call	Resolves to
Function.create	`await $.Function.create({ kind: 'code' })`	Function
Function.get	`await $.Function.get({ id: 'function_1' })`	Function
Function.list	`await $.Function.list({ limit: 20 })`	list of Function
Function.update	`await $.Function.update({ id: 'function_1', kind: 'code' })`	Function
Function.delete	`await $.Function.delete({ id: 'function_1' })`	Function

Fund

Operation	Call	Resolves to
Fund.create	`await $.Fund.create({ name: 'Acme' })`	Fund
Fund.get	`await $.Fund.get({ id: 'fund_1' })`	Fund
Fund.list	`await $.Fund.list({ limit: 20 })`	list of Fund
Fund.update	`await $.Fund.update({ id: 'fund_1', name: 'Acme' })`	Fund
Fund.delete	`await $.Fund.delete({ id: 'fund_1' })`	Fund
Fund.call	`await $.Fund.call({ fund: 'fund_1', amount: { amount: 49, currency: 'USD' }, dueOn: '2026-10-22', purpose: 'Example purpose' })`	`call`: Capital Call, `fund`: Fund
Fund.distribute	`await $.Fund.distribute({ fund: 'fund_1', amount: { amount: 49, currency: 'USD' }, kind: 'cash' })`	`distribution`: Fund Distribution, `fund`: Fund
Fund.report	`await $.Fund.report({ fund: 'fund_1', period: 'period_1' })`	`statements`: list of Statement, `fund`: Fund

Fund Distribution

Operation	Call	Resolves to
FundDistribution.get	`await $.FundDistribution.get({ id: 'fund_distribution_1' })`	Fund Distribution
FundDistribution.list	`await $.FundDistribution.list({ limit: 20 })`	list of Fund Distribution

Funnel

Operation	Call	Resolves to
Funnel.create	`await $.Funnel.create({ steps: {} })`	Funnel
Funnel.get	`await $.Funnel.get({ id: 'funnel_1' })`	Funnel
Funnel.list	`await $.Funnel.list({ limit: 20 })`	list of Funnel
Funnel.update	`await $.Funnel.update({ id: 'funnel_1', steps: {} })`	Funnel
Funnel.delete	`await $.Funnel.delete({ id: 'funnel_1' })`	Funnel

Gathering

Operation	Call	Resolves to
Gathering.create	`await $.Gathering.create({ title: 'Acme API', at: '2026-10-22T12:00:00Z' })`	Gathering
Gathering.get	`await $.Gathering.get({ id: 'gathering_1' })`	Gathering
Gathering.list	`await $.Gathering.list({ limit: 20 })`	list of Gathering
Gathering.update	`await $.Gathering.update({ id: 'gathering_1', title: 'Acme API' })`	Gathering
Gathering.delete	`await $.Gathering.delete({ id: 'gathering_1' })`	Gathering
Gathering.register	`await $.Gathering.register({ gathering: 'gathering_1', contact: 'contact_1' })`	`registration`: Registration, `gathering`: Gathering

Goal

Operation	Call	Resolves to
Goal.create	`await $.Goal.create({ objective: 'Example objective' })`	Goal
Goal.get	`await $.Goal.get({ id: 'goal_1' })`	Goal
Goal.list	`await $.Goal.list({ limit: 20 })`	list of Goal
Goal.update	`await $.Goal.update({ id: 'goal_1', horizon: 'day' })`	Goal
Goal.delete	`await $.Goal.delete({ id: 'goal_1' })`	Goal

Guard

Operation	Call	Resolves to
Guard.create	`await $.Guard.create({ tier: 'code' })`	Guard
Guard.get	`await $.Guard.get({ id: 'guard_1' })`	Guard
Guard.list	`await $.Guard.list({ limit: 20 })`	list of Guard
Guard.update	`await $.Guard.update({ id: 'guard_1', tier: 'code' })`	Guard
Guard.delete	`await $.Guard.delete({ id: 'guard_1' })`	Guard

Handle

Operation	Call	Resolves to
Handle.create	`await $.Handle.create({ venue: 'Example venue', name: 'Acme' })`	Handle
Handle.get	`await $.Handle.get({ id: 'handle_1' })`	Handle
Handle.list	`await $.Handle.list({ limit: 20 })`	list of Handle
Handle.update	`await $.Handle.update({ id: 'handle_1', name: 'Acme' })`	Handle
Handle.connect	`await $.Handle.connect({ handle: 'handle_1', integration: 'integration_1' })`	Handle

Holder

Operation	Call	Resolves to
Holder.create	`await $.Holder.create({ party: 'party_1' })`	Holder
Holder.get	`await $.Holder.get({ id: 'holder_1' })`	Holder
Holder.list	`await $.Holder.list({ limit: 20 })`	list of Holder
Holder.update	`await $.Holder.update({ id: 'holder_1', party: 'party_1' })`	Holder

Human

Operation	Call	Resolves to
Human.create	`await $.Human.create({ name: 'Acme', email: 'ada@acme.com' })`	Human
Human.get	`await $.Human.get({ id: 'human_1' })`	Human
Human.list	`await $.Human.list({ limit: 20 })`	list of Human
Human.update	`await $.Human.update({ id: 'human_1', email: 'ada@acme.com' })`	Human
Human.delete	`await $.Human.delete({ id: 'human_1' })`	Human
Human.hold	`await $.Human.hold({ human: 'human_1', amount: { amount: 49, currency: 'USD' }, cause: 'Example cause' })`	Human
Human.invite	`await $.Human.invite({ email: 'ada@acme.com', role: 'role_1' })`	Human
Human.onboard	`await $.Human.onboard({ human: 'human_1' })`	Human
Human.recruit	`await $.Human.recruit({ email: 'ada@acme.com' })`	Human
Human.release	`await $.Human.release({ human: 'human_1', cause: 'Example cause' })`	Human
Human.remit	`await $.Human.remit({ human: 'human_1' })`	`transaction`: Transaction, `human`: Human
Human.suspend	`await $.Human.suspend({ human: 'human_1', reason: 'Example reason' })`	Human

Hypothesis

Operation	Call	Resolves to
Hypothesis.create	`await $.Hypothesis.create({ statement: 'Drafts patents for solo inventors.', kind: 'founding' })`	Hypothesis
Hypothesis.get	`await $.Hypothesis.get({ id: 'hypothesis_1' })`	Hypothesis
Hypothesis.list	`await $.Hypothesis.list({ limit: 20 })`	list of Hypothesis
Hypothesis.drop	`await $.Hypothesis.drop({ hypothesis: 'hypothesis_1', reason: 'Example reason' })`	Hypothesis
Hypothesis.test	`await $.Hypothesis.test({ hypothesis: 'hypothesis_1', experiment: 'experiment_1' })`	Hypothesis

ICP

Operation	Call	Resolves to
ICP.create	`await $.ICP.create({ description: 'The first Offer.' })`	ICP
ICP.get	`await $.ICP.get({ id: 'icp_1' })`	ICP
ICP.list	`await $.ICP.list({ limit: 20 })`	list of ICP
ICP.update	`await $.ICP.update({ id: 'icp_1', description: 'The first Offer.' })`	ICP
ICP.delete	`await $.ICP.delete({ id: 'icp_1' })`	ICP

Idea

Operation	Call	Resolves to
Idea.create	`await $.Idea.create({ statement: 'Drafts patents for solo inventors.' })`	Idea
Idea.get	`await $.Idea.get({ id: 'idea_1' })`	Idea
Idea.list	`await $.Idea.list({ limit: 20 })`	list of Idea
Idea.pursue	`await $.Idea.pursue({ idea: 'idea_1' })`	`startup`: Startup, `idea`: Idea

Implementation

Operation	Call	Resolves to
Implementation.create	`await $.Implementation.create({ kind: 'managed' })`	Implementation
Implementation.get	`await $.Implementation.get({ id: 'implementation_1' })`	Implementation
Implementation.list	`await $.Implementation.list({ limit: 20 })`	list of Implementation
Implementation.update	`await $.Implementation.update({ id: 'implementation_1', kind: 'managed' })`	Implementation
Implementation.delete	`await $.Implementation.delete({ id: 'implementation_1' })`	Implementation

Incident

Operation	Call	Resolves to
Incident.create	`await $.Incident.create({ severity: 'minor', detectedAt: '2026-10-22T12:00:00Z' })`	Incident
Incident.get	`await $.Incident.get({ id: 'incident_1' })`	Incident
Incident.list	`await $.Incident.list({ limit: 20 })`	list of Incident
Incident.update	`await $.Incident.update({ id: 'incident_1', severity: 'minor' })`	Incident
Incident.delete	`await $.Incident.delete({ id: 'incident_1' })`	Incident
Incident.acknowledge	`await $.Incident.acknowledge({ incident: 'incident_1' })`	Incident
Incident.open	`await $.Incident.open({ severity: 'sev1', cause: 'Example cause' })`	Incident
Incident.resolve	`await $.Incident.resolve({ incident: 'incident_1', summary: 'Example summary' })`	Incident

Instrument

Operation	Call	Resolves to
Instrument.get	`await $.Instrument.get({ id: 'instrument_1' })`	Instrument
Instrument.list	`await $.Instrument.list({ limit: 20 })`	list of Instrument
Instrument.cancel	`await $.Instrument.cancel({ instrument: 'instrument_1', reason: 'unvested' })`	Instrument
Instrument.convert	`await $.Instrument.convert({ instrument: 'instrument_1', roundPrice: { amount: 49, currency: 'USD' } })`	`shares`: list of Share, `instrument`: Instrument
Instrument.exercise	`await $.Instrument.exercise({ instrument: 'instrument_1', quantity: 1 })`	`share`: Share, `instrument`: Instrument
Instrument.grant	`await $.Instrument.grant({ holder: 'holder_1', quantity: 1, strike: { amount: 49, currency: 'USD' }, vesting: {} })`	Instrument

Integration

Operation	Call	Resolves to
Integration.create	`await $.Integration.create({ acquired: 'owned', scope: 'studio', mode: 'mirror' })`	Integration
Integration.get	`await $.Integration.get({ id: 'integration_1' })`	Integration
Integration.list	`await $.Integration.list({ limit: 20 })`	list of Integration
Integration.update	`await $.Integration.update({ id: 'integration_1', scope: 'studio' })`	Integration
Integration.delete	`await $.Integration.delete({ id: 'integration_1' })`	Integration
Integration.call	`await $.Integration.call({ integration: 'integration_1', method: 'GET', path: '/' })`	`status`: `integer`, `body`: `json`, `integration`: Integration
Integration.connect	`await $.Integration.connect({ system: 'system_1', scope: 'studio', grants: ['Example grants'] })`	`integration`: Integration, `connectUrl`: `url`
Integration.pause	`await $.Integration.pause({ integration: 'integration_1' })`	Integration
Integration.reconnect	`await $.Integration.reconnect({ integration: 'integration_1' })`	`connectUrl`: `url`, `integration`: Integration
Integration.refresh	`await $.Integration.refresh({ integration: 'integration_1' })`	Integration
Integration.resume	`await $.Integration.resume({ integration: 'integration_1' })`	Integration
Integration.revoke	`await $.Integration.revoke({ integration: 'integration_1' })`	Integration
Integration.sync	`await $.Integration.sync({ integration: 'integration_1' })`	Integration

Interface

Operation	Call	Resolves to
Interface.create	`await $.Interface.create({ kind: 'api' })`	Interface
Interface.get	`await $.Interface.get({ id: 'interface_1' })`	Interface
Interface.list	`await $.Interface.list({ limit: 20 })`	list of Interface
Interface.update	`await $.Interface.update({ id: 'interface_1', kind: 'api' })`	Interface
Interface.delete	`await $.Interface.delete({ id: 'interface_1' })`	Interface

Interview

Operation	Call	Resolves to
Interview.create	`await $.Interview.create({ script: 'template_1' })`	Interview
Interview.get	`await $.Interview.get({ id: 'interview_1' })`	Interview
Interview.list	`await $.Interview.list({ limit: 20 })`	list of Interview

Invoice

Operation	Call	Resolves to
Invoice.create	`await $.Invoice.create({ total: { amount: 49, currency: 'USD' }, due: '2026-10-22' })`	Invoice
Invoice.get	`await $.Invoice.get({ id: 'invoice_1' })`	Invoice
Invoice.list	`await $.Invoice.list({ limit: 20 })`	list of Invoice
Invoice.update	`await $.Invoice.update({ id: 'invoice_1', total: { amount: 49, currency: 'USD' } })`	Invoice
Invoice.bill	`await $.Invoice.bill({ invoice: 'invoice_1' })`	Invoice
Invoice.collect	`await $.Invoice.collect({ invoice: 'invoice_1' })`	Invoice
Invoice.refund	`await $.Invoice.refund({ invoice: 'invoice_1', reason: 'Example reason' })`	Invoice
Invoice.void	`await $.Invoice.void({ invoice: 'invoice_1', reason: 'Example reason' })`	Invoice

Issue

Operation	Call	Resolves to
Issue.create	`await $.Issue.create({ by: 'worker_1' })`	Issue
Issue.get	`await $.Issue.get({ id: 'issue_1' })`	Issue
Issue.list	`await $.Issue.list({ limit: 20 })`	list of Issue
Issue.update	`await $.Issue.update({ id: 'issue_1', kind: 'bug' })`	Issue
Issue.delete	`await $.Issue.delete({ id: 'issue_1' })`	Issue
Issue.estimate	`await $.Issue.estimate({ issue: 'issue_1', days: 1 })`	Issue
Issue.reopen	`await $.Issue.reopen({ issue: 'issue_1', reason: 'Example reason' })`	Issue
Issue.resolve	`await $.Issue.resolve({ issue: 'issue_1', resolution: 'Example resolution' })`	Issue
Issue.schedule	`await $.Issue.schedule({ issue: 'issue_1', week: '2026-10-22' })`	Issue
Issue.triage	`await $.Issue.triage({ issue: 'issue_1' })`	Issue

Key Result

Operation	Call	Resolves to
KeyResult.create	`await $.KeyResult.create({ baseline: 1, target: 1, deadline: '2026-10-22' })`	Key Result
KeyResult.get	`await $.KeyResult.get({ id: 'key_result_1' })`	Key Result
KeyResult.list	`await $.KeyResult.list({ limit: 20 })`	list of Key Result
KeyResult.update	`await $.KeyResult.update({ id: 'key_result_1', baseline: 1 })`	Key Result
KeyResult.delete	`await $.KeyResult.delete({ id: 'key_result_1' })`	Key Result

Keyword

Operation	Call	Resolves to
Keyword.create	`await $.Keyword.create({ phrase: 'Example phrase' })`	Keyword
Keyword.get	`await $.Keyword.get({ id: 'keyword_1' })`	Keyword
Keyword.list	`await $.Keyword.list({ limit: 20 })`	list of Keyword
Keyword.update	`await $.Keyword.update({ id: 'keyword_1', form: 'search' })`	Keyword
Keyword.delete	`await $.Keyword.delete({ id: 'keyword_1' })`	Keyword
Keyword.measure	`await $.Keyword.measure({ keyword: 'keyword_1' })`	Keyword

Lead

Operation	Call	Resolves to
Lead.create	`await $.Lead.create({ email: 'ada@acme.com' })`	Lead
Lead.get	`await $.Lead.get({ id: 'lead_1' })`	Lead
Lead.list	`await $.Lead.list({ limit: 20 })`	list of Lead
Lead.update	`await $.Lead.update({ id: 'lead_1', owner: 'worker_1' })`	Lead
Lead.delete	`await $.Lead.delete({ id: 'lead_1' })`	Lead
Lead.assign	`await $.Lead.assign({ lead: 'lead_1' })`	Lead
Lead.convert	`await $.Lead.convert({ lead: 'lead_1', offer: 'offer_1', route: 'Example route' })`	`deal`: Deal, `lead`: Lead
Lead.disqualify	`await $.Lead.disqualify({ lead: 'lead_1', reason: 'noFit' })`	Lead
Lead.nurture	`await $.Lead.nurture({ lead: 'lead_1' })`	Lead
Lead.qualify	`await $.Lead.qualify({ lead: 'lead_1', offer: 'offer_1' })`	`deal`: Deal, `lead`: Lead

Lifecycle

Operation	Call	Resolves to
Lifecycle.get	`await $.Lifecycle.get({ id: 'lifecycle_1' })`	Lifecycle
Lifecycle.list	`await $.Lifecycle.list({ limit: 20 })`	list of Lifecycle
Lifecycle.update	`await $.Lifecycle.update({ id: 'lifecycle_1', states: ['Example states'] })`	Lifecycle

Limit

Operation	Call	Resolves to
Limit.create	`await $.Limit.create({ amount: { amount: 49, currency: 'USD' } })`	Limit
Limit.get	`await $.Limit.get({ id: 'limit_1' })`	Limit
Limit.list	`await $.Limit.list({ limit: 20 })`	list of Limit
Limit.update	`await $.Limit.update({ id: 'limit_1', amount: { amount: 49, currency: 'USD' } })`	Limit
Limit.delete	`await $.Limit.delete({ id: 'limit_1' })`	Limit
Limit.raise	`await $.Limit.raise({ limit: 'limit_1', to: {} })`	Limit

Mailbox

Operation	Call	Resolves to
Mailbox.create	`await $.Mailbox.create({ medium: 'email', address: 'ada@acme.com', stream: 'transactional' })`	Mailbox
Mailbox.get	`await $.Mailbox.get({ id: 'mailbox_1' })`	Mailbox
Mailbox.list	`await $.Mailbox.list({ limit: 20 })`	list of Mailbox
Mailbox.update	`await $.Mailbox.update({ id: 'mailbox_1', address: 'ada@acme.com' })`	Mailbox
Mailbox.rest	`await $.Mailbox.rest({ mailbox: 'mailbox_1', reason: 'complaints' })`	Mailbox
Mailbox.retire	`await $.Mailbox.retire({ mailbox: 'mailbox_1' })`	Mailbox
Mailbox.warm	`await $.Mailbox.warm({ mailbox: 'mailbox_1', cap: 1 })`	Mailbox

Mandate

Operation	Call	Resolves to
Mandate.create	`await $.Mandate.create({ expiresAt: '2026-10-22T12:00:00Z' })`	Mandate
Mandate.get	`await $.Mandate.get({ id: 'mandate_1' })`	Mandate
Mandate.list	`await $.Mandate.list({ limit: 20 })`	list of Mandate
Mandate.update	`await $.Mandate.update({ id: 'mandate_1', expiresAt: '2026-10-22T12:00:00Z' })`	Mandate
Mandate.delete	`await $.Mandate.delete({ id: 'mandate_1' })`	Mandate
Mandate.authorize	`await $.Mandate.authorize({ agent: 'agent_1', verb: 'Example verb', limit: 'limit_1' })`	Mandate
Mandate.pause	`await $.Mandate.pause({ mandate: 'mandate_1' })`	Mandate
Mandate.resume	`await $.Mandate.resume({ mandate: 'mandate_1' })`	Mandate
Mandate.revoke	`await $.Mandate.revoke({ mandate: 'mandate_1' })`	Mandate
Mandate.spend	`await $.Mandate.spend({ mandate: 'mandate_1', amount: { amount: 49, currency: 'USD' }, payee: 'Example payee' })`	`transaction`: Transaction, `mandate`: Mandate

Mapping

Operation	Call	Resolves to
Mapping.create	`await $.Mapping.create({ verb: 'Meeting.book' })`	Mapping
Mapping.get	`await $.Mapping.get({ id: 'mapping_1' })`	Mapping
Mapping.list	`await $.Mapping.list({ limit: 20 })`	list of Mapping
Mapping.update	`await $.Mapping.update({ id: 'mapping_1', verb: 'Meeting.book' })`	Mapping
Mapping.delete	`await $.Mapping.delete({ id: 'mapping_1' })`	Mapping

Market

Operation	Call	Resolves to
Market.create	`await $.Market.create({ countries: ['Example countries'], currency: 'USD', locales: ['Example locales'] })`	Market
Market.get	`await $.Market.get({ id: 'market_1' })`	Market
Market.list	`await $.Market.list({ limit: 20 })`	list of Market
Market.update	`await $.Market.update({ id: 'market_1', currency: 'USD' })`	Market
Market.delete	`await $.Market.delete({ id: 'market_1' })`	Market
Market.enter	`await $.Market.enter({ startup: 'startup_1', market: 'market_1' })`	Market

Meeting

Operation	Call	Resolves to
Meeting.create	`await $.Meeting.create({ at: '2026-10-22T12:00:00Z' })`	Meeting
Meeting.get	`await $.Meeting.get({ id: 'meeting_1' })`	Meeting
Meeting.list	`await $.Meeting.list({ limit: 20 })`	list of Meeting
Meeting.update	`await $.Meeting.update({ id: 'meeting_1', at: '2026-10-22T12:00:00Z' })`	Meeting
Meeting.delete	`await $.Meeting.delete({ id: 'meeting_1' })`	Meeting
Meeting.book	`await $.Meeting.book({ contact: 'contact_1', at: '2026-10-22T12:00:00Z' })`	Meeting

Member Directory

Operation	Call	Resolves to
MemberDirectory.create	`await $.MemberDirectory.create({ groupRoles: {} })`	Member Directory
MemberDirectory.get	`await $.MemberDirectory.get({ id: 'member_directory_1' })`	Member Directory
MemberDirectory.list	`await $.MemberDirectory.list({ limit: 20 })`	list of Member Directory
MemberDirectory.update	`await $.MemberDirectory.update({ id: 'member_directory_1', groupRoles: {} })`	Member Directory
MemberDirectory.deactivate	`await $.MemberDirectory.deactivate({ directory: 'member_directory_1' })`	Member Directory
MemberDirectory.deprovision	`await $.MemberDirectory.deprovision({ directory: 'member_directory_1', person: 'person_1' })`	`person`: Person, `memberDirectory`: Member Directory
MemberDirectory.provision	`await $.MemberDirectory.provision({ tenant: 'tenant_1' })`	Member Directory

Memory

Operation	Call	Resolves to
Memory.create	`await $.Memory.create({ id: 'memory_1', type: ['noun_1'] })`	Memory
Memory.get	`await $.Memory.get({ id: 'memory_1' })`	Memory
Memory.list	`await $.Memory.list({ limit: 20 })`	list of Memory
Memory.update	`await $.Memory.update({ id: 'memory_1', type: ['noun_1'] })`	Memory
Memory.delete	`await $.Memory.delete({ id: 'memory_1' })`	Memory

Message

Operation	Call	Resolves to
Message.create	`await $.Message.create({ medium: 'email', direction: 'inbound', body: 'Example body' })`	Message
Message.get	`await $.Message.get({ id: 'message_1' })`	Message
Message.list	`await $.Message.list({ limit: 20 })`	list of Message
Message.update	`await $.Message.update({ id: 'message_1', medium: 'email' })`	Message
Message.delete	`await $.Message.delete({ id: 'message_1' })`	Message
Message.broadcast	`await $.Message.broadcast({ message: 'message_1', audience: 'audience_1' })`	`messages`: list of Message, `message`: Message
Message.schedule	`await $.Message.schedule({ message: 'message_1', at: '2026-10-22T12:00:00Z' })`	Message

Meter

Operation	Call	Resolves to
Meter.create	`await $.Meter.create({ unit: 'call', of: 'Reminder.sent', aggregation: 'sum', window: 'month' })`	Meter
Meter.get	`await $.Meter.get({ id: 'meter_1' })`	Meter
Meter.list	`await $.Meter.list({ limit: 20 })`	list of Meter
Meter.update	`await $.Meter.update({ id: 'meter_1', unit: 'call' })`	Meter
Meter.delete	`await $.Meter.delete({ id: 'meter_1' })`	Meter

Metric

Operation	Call	Resolves to
Metric.create	`await $.Metric.create({ query: 'Example query' })`	Metric
Metric.get	`await $.Metric.get({ id: 'metric_1' })`	Metric
Metric.list	`await $.Metric.list({ limit: 20 })`	list of Metric
Metric.update	`await $.Metric.update({ id: 'metric_1', query: 'Example query' })`	Metric
Metric.delete	`await $.Metric.delete({ id: 'metric_1' })`	Metric
Metric.define	`await $.Metric.define({ name: 'Acme', query: 'Example query', unit: 'Example unit' })`	Metric
Metric.query	`await $.Metric.query({ shape: 'trend' })`	`rows`: `json`, `metric`: Metric
Metric.watch	`await $.Metric.watch({ metric: 'metric_1', threshold: 1, direction: 'above' })`	`watch`: Watch, `metric`: Metric

Minimum Success Criteria

Operation	Call	Resolves to
MinimumSuccessCriteria.create	`await $.MinimumSuccessCriteria.create({ objective: 'Example objective', metric: 'metric_1', value: 1, by: '2026-10-22' })`	Minimum Success Criteria
MinimumSuccessCriteria.get	`await $.MinimumSuccessCriteria.get({ id: 'minimum_success_criteria_1' })`	Minimum Success Criteria
MinimumSuccessCriteria.list	`await $.MinimumSuccessCriteria.list({ limit: 20 })`	list of Minimum Success Criteria
MinimumSuccessCriteria.update	`await $.MinimumSuccessCriteria.update({ id: 'minimum_success_criteria_1', metric: 'metric_1' })`	Minimum Success Criteria
MinimumSuccessCriteria.delete	`await $.MinimumSuccessCriteria.delete({ id: 'minimum_success_criteria_1' })`	Minimum Success Criteria

Mode

Operation	Call	Resolves to
Mode.get	`await $.Mode.get({ id: 'mode_1' })`	Mode
Mode.list	`await $.Mode.list({ limit: 20 })`	list of Mode

Monitor

Operation	Call	Resolves to
Monitor.create	`await $.Monitor.create({ kind: 'internal', target: '/health' })`	Monitor
Monitor.get	`await $.Monitor.get({ id: 'monitor_1' })`	Monitor
Monitor.list	`await $.Monitor.list({ limit: 20 })`	list of Monitor
Monitor.update	`await $.Monitor.update({ id: 'monitor_1', kind: 'internal' })`	Monitor
Monitor.check	`await $.Monitor.check({ monitor: 'monitor_1' })`	Monitor

Motion

Operation	Call	Resolves to
Motion.get	`await $.Motion.get({ id: 'motion_1' })`	Motion
Motion.list	`await $.Motion.list({ limit: 20 })`	list of Motion

Noun

Operation	Call	Resolves to
Noun.create	`await $.Noun.create({ name: 'Acme' })`	Noun
Noun.get	`await $.Noun.get({ id: 'noun_1' })`	Noun
Noun.list	`await $.Noun.list({ limit: 20 })`	list of Noun
Noun.update	`await $.Noun.update({ id: 'noun_1', name: 'Acme' })`	Noun
Noun.delete	`await $.Noun.delete({ id: 'noun_1' })`	Noun
Noun.retire	`await $.Noun.retire({ noun: 'noun_1' })`	`version`: Version, `noun`: Noun
Noun.trace	`await $.Noun.trace({ noun: 'noun_1' })`	`uses`: `json`, `noun`: Noun

Offer

Operation	Call	Resolves to
Offer.create	`await $.Offer.create({ price: { amount: 49, currency: 'USD' } })`	Offer
Offer.get	`await $.Offer.get({ id: 'offer_1' })`	Offer
Offer.list	`await $.Offer.list({ limit: 20 })`	list of Offer
Offer.update	`await $.Offer.update({ id: 'offer_1', price: { amount: 49, currency: 'USD' } })`	Offer
Offer.delete	`await $.Offer.delete({ id: 'offer_1' })`	Offer
Offer.accept	`await $.Offer.accept({ offer: 'offer_1', party: 'Ada Lovelace' })`	`customer`: Customer, `offer`: Offer
Offer.grant	`await $.Offer.grant({ offer: 'offer_1', verb: 'verb_1' })`	`entitlement`: Entitlement, `offer`: Offer
Offer.publish	`await $.Offer.publish({ offer: 'offer_1' })`	Offer
Offer.subscribe	`await $.Offer.subscribe({ offer: 'offer_1' })`	`subscription`: Subscription, `offer`: Offer
Offer.trial	`await $.Offer.trial({ offer: 'offer_1', customer: 'customer_1', days: 1 })`	`subscription`: Subscription, `offer`: Offer
Offer.withdraw	`await $.Offer.withdraw({ offer: 'offer_1' })`	Offer

Opening

Operation	Call	Resolves to
Opening.create	`await $.Opening.create({ role: 'role_1', kind: 'floor', reason: 'floor', hypothesis: 'hypothesis_1' })`	Opening
Opening.get	`await $.Opening.get({ id: 'opening_1' })`	Opening
Opening.list	`await $.Opening.list({ limit: 20 })`	list of Opening
Opening.update	`await $.Opening.update({ id: 'opening_1', role: 'role_1' })`	Opening
Opening.delete	`await $.Opening.delete({ id: 'opening_1' })`	Opening

Order

Operation	Call	Resolves to
Order.create	`await $.Order.create({ total: { amount: 49, currency: 'USD' } })`	Order
Order.get	`await $.Order.get({ id: 'order_1' })`	Order
Order.list	`await $.Order.list({ limit: 20 })`	list of Order
Order.update	`await $.Order.update({ id: 'order_1', total: { amount: 49, currency: 'USD' } })`	Order
Order.cancel	`await $.Order.cancel({ order: 'order_1' })`	Order
Order.confirm	`await $.Order.confirm({ order: 'order_1' })`	Order
Order.deliver	`await $.Order.deliver({ order: 'order_1', work: {} })`	Order
Order.dispute	`await $.Order.dispute({ order: 'order_1', reason: 'Example reason' })`	Order
Order.fulfill	`await $.Order.fulfill({ order: 'order_1' })`	Order
Order.pay	`await $.Order.pay({ order: 'order_1' })`	Order
Order.place	`await $.Order.place({ offer: 'offer_1' })`	Order
Order.refund	`await $.Order.refund({ order: 'order_1', reason: 'Example reason' })`	Order
Order.revise	`await $.Order.revise({ order: 'order_1', changes: 'Example changes' })`	Order
Order.screen	`await $.Order.screen({ order: 'order_1' })`	`outcome`: `string`, `risk`: `number`, `rule`: `string`, `order`: Order
Order.start	`await $.Order.start({ order: 'order_1', received: {} })`	Order

Organization

Operation	Call	Resolves to
Organization.create	`await $.Organization.create({ name: 'Acme' })`	Organization
Organization.get	`await $.Organization.get({ id: 'organization_1' })`	Organization
Organization.list	`await $.Organization.list({ limit: 20 })`	list of Organization
Organization.update	`await $.Organization.update({ id: 'organization_1', name: 'Acme' })`	Organization
Organization.delete	`await $.Organization.delete({ id: 'organization_1' })`	Organization
Organization.merge	`await $.Organization.merge({ organization: 'organization_1', into: 'organization_1' })`	Organization

Outcome Contract

Operation	Call	Resolves to
OutcomeContract.get	`await $.OutcomeContract.get({ id: 'outcome_contract_1' })`	Outcome Contract
OutcomeContract.list	`await $.OutcomeContract.list({ limit: 20 })`	list of Outcome Contract
OutcomeContract.update	`await $.OutcomeContract.update({ id: 'outcome_contract_1', done: 'Order.accepted' })`	Outcome Contract

Page

Operation	Call	Resolves to
Page.create	`await $.Page.create({ path: '/' })`	Page
Page.get	`await $.Page.get({ id: 'page_1' })`	Page
Page.list	`await $.Page.list({ limit: 20 })`	list of Page
Page.update	`await $.Page.update({ id: 'page_1', path: '/' })`	Page
Page.delete	`await $.Page.delete({ id: 'page_1' })`	Page

Partner

Operation	Call	Resolves to
Partner.create	`await $.Partner.create({ name: 'Acme', side: 'supply' })`	Partner
Partner.get	`await $.Partner.get({ id: 'partner_1' })`	Partner
Partner.list	`await $.Partner.list({ limit: 20 })`	list of Partner
Partner.update	`await $.Partner.update({ id: 'partner_1', side: 'supply' })`	Partner
Partner.delete	`await $.Partner.delete({ id: 'partner_1' })`	Partner

Party

Operation	Call	Resolves to
Party.create	`await $.Party.create({ name: 'Acme' })`	Party
Party.get	`await $.Party.get({ id: 'party_1' })`	Party
Party.list	`await $.Party.list({ limit: 20 })`	list of Party
Party.update	`await $.Party.update({ id: 'party_1', name: 'Acme' })`	Party
Party.delete	`await $.Party.delete({ id: 'party_1' })`	Party
Party.screen	`await $.Party.screen({ party: 'party_1' })`	`screening`: Screening, `party`: Party

Pay Run

Operation	Call	Resolves to
PayRun.get	`await $.PayRun.get({ id: 'pay_run_1' })`	Pay Run
PayRun.list	`await $.PayRun.list({ limit: 20 })`	list of Pay Run
PayRun.approve	`await $.PayRun.approve({ payRun: 'pay_run_1' })`	Pay Run
PayRun.pay	`await $.PayRun.pay({ payRun: 'pay_run_1' })`	`payRun`: Pay Run, `transaction`: Transaction
PayRun.prepare	`await $.PayRun.prepare({ company: 'company_1', periodStart: '2026-10-22', periodEnd: '2026-10-22', payDate: '2026-10-22' })`	Pay Run
PayRun.void	`await $.PayRun.void({ payRun: 'pay_run_1', reason: 'Example reason' })`	Pay Run

Payment Source

Operation	Call	Resolves to
PaymentSource.get	`await $.PaymentSource.get({ id: 'payment_source_1' })`	Payment Source
PaymentSource.list	`await $.PaymentSource.list({ limit: 20 })`	list of Payment Source
PaymentSource.update	`await $.PaymentSource.update({ id: 'payment_source_1', kind: 'card' })`	Payment Source
PaymentSource.add	`await $.PaymentSource.add({ customer: 'customer_1', kind: 'card' })`	Payment Source
PaymentSource.remove	`await $.PaymentSource.remove({ paymentSource: 'payment_source_1' })`	Payment Source

Period

Operation	Call	Resolves to
Period.get	`await $.Period.get({ id: 'period_1' })`	Period
Period.list	`await $.Period.list({ limit: 20 })`	list of Period
Period.update	`await $.Period.update({ id: 'period_1', month: '2026-10-22' })`	Period
Period.close	`await $.Period.close({ period: 'period_1' })`	Period
Period.lock	`await $.Period.lock({ period: 'period_1' })`	Period
Period.recognize	`await $.Period.recognize({ period: 'period_1' })`	`entries`: list of Entry, `period`: Period

Permission

Operation	Call	Resolves to
Permission.create	`await $.Permission.create({ scope: 'Example scope' })`	Permission
Permission.get	`await $.Permission.get({ id: 'permission_1' })`	Permission
Permission.list	`await $.Permission.list({ limit: 20 })`	list of Permission
Permission.update	`await $.Permission.update({ id: 'permission_1', limit: 'limit_1' })`	Permission
Permission.delete	`await $.Permission.delete({ id: 'permission_1' })`	Permission

Person

Operation	Call	Resolves to
Person.create	`await $.Person.create({ name: 'Acme' })`	Person
Person.get	`await $.Person.get({ id: 'person_1' })`	Person
Person.list	`await $.Person.list({ limit: 20 })`	list of Person
Person.update	`await $.Person.update({ id: 'person_1', verified: true })`	Person
Person.delete	`await $.Person.delete({ id: 'person_1' })`	Person

Persona

Operation	Call	Resolves to
Persona.create	`await $.Persona.create({ job: 'Example job' })`	Persona
Persona.get	`await $.Persona.get({ id: 'persona_1' })`	Persona
Persona.list	`await $.Persona.list({ limit: 20 })`	list of Persona
Persona.update	`await $.Persona.update({ id: 'persona_1', from: 'Hypothesis#approach@v1' })`	Persona
Persona.delete	`await $.Persona.delete({ id: 'persona_1' })`	Persona

Play

Operation	Call	Resolves to
Play.create	`await $.Play.create({ family: 'demand' })`	Play
Play.get	`await $.Play.get({ id: 'play_1' })`	Play
Play.list	`await $.Play.list({ limit: 20 })`	list of Play
Play.update	`await $.Play.update({ id: 'play_1', family: 'demand' })`	Play
Play.delete	`await $.Play.delete({ id: 'play_1' })`	Play
Play.apply	`await $.Play.apply({ play: 'play_1', cohort: 'Example cohort' })`	`experiment`: Experiment, `play`: Play

Play Mix

Operation	Call	Resolves to
PlayMix.get	`await $.PlayMix.get({ id: 'play_mix_1' })`	Play Mix
PlayMix.list	`await $.PlayMix.list({ limit: 20 })`	list of Play Mix
PlayMix.compile	`await $.PlayMix.compile({ startup: 'startup_1' })`	Play Mix

Policy

Operation	Call	Resolves to
Policy.create	`await $.Policy.create({ rule: 'Example rule' })`	Policy
Policy.get	`await $.Policy.get({ id: 'policy_1' })`	Policy
Policy.list	`await $.Policy.list({ limit: 20 })`	list of Policy
Policy.update	`await $.Policy.update({ id: 'policy_1', rule: 'Example rule' })`	Policy
Policy.delete	`await $.Policy.delete({ id: 'policy_1' })`	Policy

Portal

Operation	Call	Resolves to
Portal.create	`await $.Portal.create({ path: '/' })`	Portal
Portal.get	`await $.Portal.get({ id: 'portal_1' })`	Portal
Portal.list	`await $.Portal.list({ limit: 20 })`	list of Portal
Portal.update	`await $.Portal.update({ id: 'portal_1', path: '/' })`	Portal
Portal.delete	`await $.Portal.delete({ id: 'portal_1' })`	Portal

Portfolio

Operation	Call	Resolves to
Portfolio.create	`await $.Portfolio.create({ id: 'portfolio_1', type: ['noun_1'] })`	Portfolio
Portfolio.get	`await $.Portfolio.get({ id: 'portfolio_1' })`	Portfolio
Portfolio.list	`await $.Portfolio.list({ limit: 20 })`	list of Portfolio
Portfolio.update	`await $.Portfolio.update({ id: 'portfolio_1', membership: 'held' })`	Portfolio
Portfolio.delete	`await $.Portfolio.delete({ id: 'portfolio_1' })`	Portfolio
Portfolio.brake	`await $.Portfolio.brake({ portfolio: 'portfolio_1', effects: ['send'], reason: 'Example reason', until: '2026-10-22T12:00:00Z' })`	`brake`: Setting, `portfolio`: Portfolio
Portfolio.lift	`await $.Portfolio.lift({ portfolio: 'portfolio_1', brake: 'setting_1', reason: 'Example reason' })`	`brake`: Setting, `portfolio`: Portfolio

Post

Operation	Call	Resolves to
Post.create	`await $.Post.create({ format: 'Example format' })`	Post
Post.get	`await $.Post.get({ id: 'post_1' })`	Post
Post.list	`await $.Post.list({ limit: 20 })`	list of Post
Post.update	`await $.Post.update({ id: 'post_1', publishAt: '2026-10-22T12:00:00Z' })`	Post
Post.publish	`await $.Post.publish({ post: 'post_1' })`	Post
Post.schedule	`await $.Post.schedule({ post: 'post_1', at: '2026-10-22T12:00:00Z' })`	Post
Post.withdraw	`await $.Post.withdraw({ post: 'post_1', reason: 'Example reason' })`	Post

Problem

Operation	Call	Resolves to
Problem.create	`await $.Problem.create({ statement: 'Drafts patents for solo inventors.' })`	Problem
Problem.get	`await $.Problem.get({ id: 'problem_1' })`	Problem
Problem.list	`await $.Problem.list({ limit: 20 })`	list of Problem
Problem.update	`await $.Problem.update({ id: 'problem_1', statement: 'Drafts patents for solo inventors.' })`	Problem
Problem.delete	`await $.Problem.delete({ id: 'problem_1' })`	Problem
Problem.rank	`await $.Problem.rank({ icp: 'icp_1' })`	list of Problem
Problem.suggest	`await $.Problem.suggest({ text: 'Example text' })`	`evidence`: Evidence, `problem`: Problem

Process

Operation	Call	Resolves to
Process.create	`await $.Process.create({ name: 'Acme' })`	Process
Process.get	`await $.Process.get({ id: 'process_1' })`	Process
Process.list	`await $.Process.list({ limit: 20 })`	list of Process
Process.update	`await $.Process.update({ id: 'process_1', name: 'Acme' })`	Process
Process.delete	`await $.Process.delete({ id: 'process_1' })`	Process
Process.enable	`await $.Process.enable({ process: 'process_1' })`	Process
Process.pause	`await $.Process.pause({ process: 'process_1' })`	Process

Product

Operation	Call	Resolves to
Product.create	`await $.Product.create({ name: 'Acme', promise: 'A first draft within one day.' })`	Product
Product.get	`await $.Product.get({ id: 'product_1' })`	Product
Product.list	`await $.Product.list({ limit: 20 })`	list of Product
Product.update	`await $.Product.update({ id: 'product_1', name: 'Acme' })`	Product
Product.delete	`await $.Product.delete({ id: 'product_1' })`	Product

Product Template

Operation	Call	Resolves to
ProductTemplate.create	`await $.ProductTemplate.create({ slug: 'acme', kind: 'data', supply: 'Example supply', worker: 'agents', buyer: 'human', earningModel: 'subscription' })`	Product Template
ProductTemplate.get	`await $.ProductTemplate.get({ id: 'product_template_1' })`	Product Template
ProductTemplate.list	`await $.ProductTemplate.list({ limit: 20 })`	list of Product Template
ProductTemplate.update	`await $.ProductTemplate.update({ id: 'product_template_1', slug: 'acme' })`	Product Template
ProductTemplate.delete	`await $.ProductTemplate.delete({ id: 'product_template_1' })`	Product Template

Project

Operation	Call	Resolves to
Project.create	`await $.Project.create({ startsOn: '2026-10-22' })`	Project
Project.get	`await $.Project.get({ id: 'project_1' })`	Project
Project.list	`await $.Project.list({ limit: 20 })`	list of Project
Project.update	`await $.Project.update({ id: 'project_1', startsOn: '2026-10-22' })`	Project
Project.delete	`await $.Project.delete({ id: 'project_1' })`	Project

Proof

Operation	Call	Resolves to
Proof.get	`await $.Proof.get({ id: 'proof_1' })`	Proof
Proof.list	`await $.Proof.list({ limit: 20 })`	list of Proof

Prospect

Operation	Call	Resolves to
Prospect.create	`await $.Prospect.create({ foundIn: 'Example found in', basis: 'Example basis' })`	Prospect
Prospect.get	`await $.Prospect.get({ id: 'prospect_1' })`	Prospect
Prospect.list	`await $.Prospect.list({ limit: 20 })`	list of Prospect
Prospect.update	`await $.Prospect.update({ id: 'prospect_1', foundIn: 'Example found in' })`	Prospect
Prospect.delete	`await $.Prospect.delete({ id: 'prospect_1' })`	Prospect
Prospect.engage	`await $.Prospect.engage({ prospect: 'prospect_1' })`	`lead`: Lead, `prospect`: Prospect

Publication

Operation	Call	Resolves to
Publication.get	`await $.Publication.get({ id: 'publication_1' })`	Publication
Publication.list	`await $.Publication.list({ limit: 20 })`	list of Publication

Purpose

Operation	Call	Resolves to
Purpose.create	`await $.Purpose.create({ name: 'Acme' })`	Purpose
Purpose.get	`await $.Purpose.get({ id: 'purpose_1' })`	Purpose
Purpose.list	`await $.Purpose.list({ limit: 20 })`	list of Purpose
Purpose.update	`await $.Purpose.update({ id: 'purpose_1', name: 'Acme' })`	Purpose
Purpose.delete	`await $.Purpose.delete({ id: 'purpose_1' })`	Purpose

Question

Operation	Call	Resolves to
Question.get	`await $.Question.get({ id: 'question_1' })`	Question
Question.list	`await $.Question.list({ limit: 20 })`	list of Question

Quote

Operation	Call	Resolves to
Quote.create	`await $.Quote.create({ total: { amount: 49, currency: 'USD' }, validUntil: '2026-10-22', lines: {} })`	Quote
Quote.get	`await $.Quote.get({ id: 'quote_1' })`	Quote
Quote.list	`await $.Quote.list({ limit: 20 })`	list of Quote
Quote.update	`await $.Quote.update({ id: 'quote_1', total: { amount: 49, currency: 'USD' } })`	Quote
Quote.delete	`await $.Quote.delete({ id: 'quote_1' })`	Quote
Quote.accept	`await $.Quote.accept({ quote: 'quote_1', party: 'party_1' })`	`order`: Order, `subscription`: Subscription, `quote`: Quote
Quote.decline	`await $.Quote.decline({ quote: 'quote_1' })`	Quote
Quote.expire	`await $.Quote.expire({ quote: 'quote_1' })`	Quote
Quote.request	`await $.Quote.request({ offers: ['offer_1'] })`	`deal`: Deal, `quote`: Quote
Quote.send	`await $.Quote.send({ quote: 'quote_1' })`	Quote
Quote.supersede	`await $.Quote.supersede({ quote: 'quote_1', by: 'quote_1' })`	Quote

Readout

Operation	Call	Resolves to
Readout.create	`await $.Readout.create({ value: 1, n: 1, readability: 'A' })`	Readout
Readout.get	`await $.Readout.get({ id: 'readout_1' })`	Readout
Readout.list	`await $.Readout.list({ limit: 20 })`	list of Readout
Readout.update	`await $.Readout.update({ id: 'readout_1', value: 1 })`	Readout
Readout.delete	`await $.Readout.delete({ id: 'readout_1' })`	Readout

Recording

Operation	Call	Resolves to
Recording.get	`await $.Recording.get({ id: 'recording_1' })`	Recording
Recording.list	`await $.Recording.list({ limit: 20 })`	list of Recording

Recovery Objective

Operation	Call	Resolves to
RecoveryObjective.create	`await $.RecoveryObjective.create({ recoveryPoint: 'Example recovery point', recoveryTime: 'Example recovery time', drillEvery: 'Example drill every' })`	Recovery Objective
RecoveryObjective.get	`await $.RecoveryObjective.get({ id: 'recovery_objective_1' })`	Recovery Objective
RecoveryObjective.list	`await $.RecoveryObjective.list({ limit: 20 })`	list of Recovery Objective
RecoveryObjective.update	`await $.RecoveryObjective.update({ id: 'recovery_objective_1', lastDrill: '2026-10-22T12:00:00Z' })`	Recovery Objective
RecoveryObjective.delete	`await $.RecoveryObjective.delete({ id: 'recovery_objective_1' })`	Recovery Objective
RecoveryObjective.drill	`await $.RecoveryObjective.drill({ objective: 'recovery_objective_1' })`	Recovery Objective

Referral

Operation	Call	Resolves to
Referral.create	`await $.Referral.create({ reward: { amount: 49, currency: 'USD' } })`	Referral
Referral.get	`await $.Referral.get({ id: 'referral_1' })`	Referral
Referral.list	`await $.Referral.list({ limit: 20 })`	list of Referral
Referral.update	`await $.Referral.update({ id: 'referral_1', reward: { amount: 49, currency: 'USD' } })`	Referral
Referral.delete	`await $.Referral.delete({ id: 'referral_1' })`	Referral

Registration

Operation	Call	Resolves to
Registration.create	`await $.Registration.create({ registeredAt: '2026-10-22T12:00:00Z' })`	Registration
Registration.get	`await $.Registration.get({ id: 'registration_1' })`	Registration
Registration.list	`await $.Registration.list({ limit: 20 })`	list of Registration
Registration.update	`await $.Registration.update({ id: 'registration_1', registeredAt: '2026-10-22T12:00:00Z' })`	Registration
Registration.delete	`await $.Registration.delete({ id: 'registration_1' })`	Registration
Registration.admit	`await $.Registration.admit({ registration: 'registration_1' })`	Registration
Registration.approve	`await $.Registration.approve({ registration: 'registration_1' })`	Registration
Registration.attend	`await $.Registration.attend({ registration: 'registration_1' })`	Registration

Relationship

Operation	Call	Resolves to
Relationship.create	`await $.Relationship.create({ predicate: 'Example predicate', inverse: 'Example inverse' })`	Relationship
Relationship.get	`await $.Relationship.get({ id: 'relationship_1' })`	Relationship
Relationship.list	`await $.Relationship.list({ limit: 20 })`	list of Relationship
Relationship.update	`await $.Relationship.update({ id: 'relationship_1', provenance: 'Stated' })`	Relationship
Relationship.delete	`await $.Relationship.delete({ id: 'relationship_1' })`	Relationship

Renewal

Operation	Call	Resolves to
Renewal.create	`await $.Renewal.create({ termEndsAt: '2026-10-22T12:00:00Z', openedAt: '2026-10-22T12:00:00Z' })`	Renewal
Renewal.get	`await $.Renewal.get({ id: 'renewal_1' })`	Renewal
Renewal.list	`await $.Renewal.list({ limit: 20 })`	list of Renewal
Renewal.update	`await $.Renewal.update({ id: 'renewal_1', termEndsAt: '2026-10-22T12:00:00Z' })`	Renewal
Renewal.delete	`await $.Renewal.delete({ id: 'renewal_1' })`	Renewal
Renewal.open	`await $.Renewal.open({ subscription: 'subscription_1' })`	Renewal

Reserved Act

Operation	Call	Resolves to
ReservedAct.create	`await $.ReservedAct.create({ jurisdiction: 'US-DE' })`	Reserved Act
ReservedAct.get	`await $.ReservedAct.get({ id: 'reserved_act_1' })`	Reserved Act
ReservedAct.list	`await $.ReservedAct.list({ limit: 20 })`	list of Reserved Act
ReservedAct.update	`await $.ReservedAct.update({ id: 'reserved_act_1', jurisdiction: 'US-DE' })`	Reserved Act
ReservedAct.delete	`await $.ReservedAct.delete({ id: 'reserved_act_1' })`	Reserved Act

Review

Operation	Call	Resolves to
Review.create	`await $.Review.create({ rating: 1 })`	Review
Review.get	`await $.Review.get({ id: 'review_1' })`	Review
Review.list	`await $.Review.list({ limit: 20 })`	list of Review
Review.update	`await $.Review.update({ id: 'review_1', rating: 1 })`	Review
Review.publish	`await $.Review.publish({ review: 'review_1' })`	Review
Review.remove	`await $.Review.remove({ review: 'review_1', reason: 'authorRequest' })`	Review
Review.withhold	`await $.Review.withhold({ review: 'review_1', reason: 'fake' })`	Review

Risk

Operation	Call	Resolves to
Risk.create	`await $.Risk.create({ scope: 'Example scope', likelihood: 1, impact: 1, owner: 'role_1' })`	Risk
Risk.get	`await $.Risk.get({ id: 'risk_1' })`	Risk
Risk.list	`await $.Risk.list({ limit: 20 })`	list of Risk
Risk.update	`await $.Risk.update({ id: 'risk_1', likelihood: 1 })`	Risk
Risk.accept	`await $.Risk.accept({ risk: 'risk_1', reason: 'Example reason' })`	Risk
Risk.assess	`await $.Risk.assess({ risk: 'risk_1', likelihood: 1, impact: 1 })`	Risk
Risk.close	`await $.Risk.close({ risk: 'risk_1', reason: 'Example reason' })`	Risk
Risk.treat	`await $.Risk.treat({ risk: 'risk_1', controls: ['control_1'] })`	Risk

Role

Operation	Call	Resolves to
Role.create	`await $.Role.create({ name: 'Acme' })`	Role
Role.get	`await $.Role.get({ id: 'role_1' })`	Role
Role.list	`await $.Role.list({ limit: 20 })`	list of Role
Role.update	`await $.Role.update({ id: 'role_1', name: 'Acme' })`	Role
Role.delete	`await $.Role.delete({ id: 'role_1' })`	Role
Role.review	`await $.Role.review({ role: 'role_1', period: 'Example period' })`	`role`: Role, `roleReview`: Role Review
Role.staff	`await $.Role.staff({ role: 'role_1', worker: 'worker_1' })`	Role
Role.vacate	`await $.Role.vacate({ role: 'role_1' })`	Role

Role Review

Operation	Call	Resolves to
RoleReview.get	`await $.RoleReview.get({ id: 'role_review_1' })`	Role Review
RoleReview.list	`await $.RoleReview.list({ limit: 20 })`	list of Role Review

Screening

Operation	Call	Resolves to
Screening.get	`await $.Screening.get({ id: 'screening_1' })`	Screening
Screening.list	`await $.Screening.list({ limit: 20 })`	list of Screening

Secret

Operation	Call	Resolves to
Secret.get	`await $.Secret.get({ id: 'secret_1' })`	Secret
Secret.list	`await $.Secret.list({ limit: 20 })`	list of Secret
Secret.revoke	`await $.Secret.revoke({ secret: 'secret_1' })`	Secret
Secret.rotate	`await $.Secret.rotate({ secret: 'secret_1' })`	Secret
Secret.store	`await $.Secret.store({ name: 'MAPS_KEY', value: 'Example value', environment: 'test' })`	Secret

Sequence

Operation	Call	Resolves to
Sequence.create	`await $.Sequence.create({ steps: {} })`	Sequence
Sequence.get	`await $.Sequence.get({ id: 'sequence_1' })`	Sequence
Sequence.list	`await $.Sequence.list({ limit: 20 })`	list of Sequence
Sequence.update	`await $.Sequence.update({ id: 'sequence_1', steps: {} })`	Sequence
Sequence.delete	`await $.Sequence.delete({ id: 'sequence_1' })`	Sequence

Service

Operation	Call	Resolves to
Service.create	`await $.Service.create({ name: 'Acme', promise: 'A first draft within one day.' })`	Service
Service.get	`await $.Service.get({ id: 'service_1' })`	Service
Service.list	`await $.Service.list({ limit: 20 })`	list of Service
Service.update	`await $.Service.update({ id: 'service_1', floor: 'none' })`	Service
Service.delete	`await $.Service.delete({ id: 'service_1' })`	Service

Setting

Operation	Call	Resolves to
Setting.create	`await $.Setting.create({ key: 'Example key', value: {} })`	Setting
Setting.get	`await $.Setting.get({ id: 'setting_1' })`	Setting
Setting.list	`await $.Setting.list({ limit: 20 })`	list of Setting
Setting.update	`await $.Setting.update({ id: 'setting_1', value: {} })`	Setting
Setting.delete	`await $.Setting.delete({ id: 'setting_1' })`	Setting

Operation	Call	Resolves to
Share.get	`await $.Share.get({ id: 'share_1' })`	Share
Share.list	`await $.Share.list({ limit: 20 })`	list of Share
Share.issue	`await $.Share.issue({ holder: 'holder_1', class: 'Example class', quantity: 1, price: { amount: 49, currency: 'USD' }, agreement: 'agreement_1' })`	Share
Share.transfer	`await $.Share.transfer({ share: 'share_1', to: 'holder_1', quantity: 1, agreement: 'agreement_1' })`	Share

Site

Operation	Call	Resolves to
Site.create	`await $.Site.create({ kind: 'api' })`	Site
Site.get	`await $.Site.get({ id: 'site_1' })`	Site
Site.list	`await $.Site.list({ limit: 20 })`	list of Site
Site.update	`await $.Site.update({ id: 'site_1', navigation: {} })`	Site
Site.delete	`await $.Site.delete({ id: 'site_1' })`	Site
Site.publish	`await $.Site.publish({ site: 'site_1' })`	Site

Skill

Operation	Call	Resolves to
Skill.create	`await $.Skill.create({ level: 1 })`	Skill
Skill.get	`await $.Skill.get({ id: 'skill_1' })`	Skill
Skill.list	`await $.Skill.list({ limit: 20 })`	list of Skill
Skill.update	`await $.Skill.update({ id: 'skill_1', level: 1 })`	Skill
Skill.delete	`await $.Skill.delete({ id: 'skill_1' })`	Skill

Software

Operation	Call	Resolves to
Software.create	`await $.Software.create({ name: 'Acme', promise: 'A first draft within one day.' })`	Software
Software.get	`await $.Software.get({ id: 'software_1' })`	Software
Software.list	`await $.Software.list({ limit: 20 })`	list of Software
Software.update	`await $.Software.update({ id: 'software_1', headless: true })`	Software
Software.delete	`await $.Software.delete({ id: 'software_1' })`	Software

Source

Operation	Call	Resolves to
Source.create	`await $.Source.create({ acquired: 'owned' })`	Source
Source.get	`await $.Source.get({ id: 'source_1' })`	Source
Source.list	`await $.Source.list({ limit: 20 })`	list of Source
Source.update	`await $.Source.update({ id: 'source_1', acquired: 'owned' })`	Source
Source.delete	`await $.Source.delete({ id: 'source_1' })`	Source

SSO Connection

Operation	Call	Resolves to
SSOConnection.create	`await $.SSOConnection.create({ protocol: 'saml' })`	SSO Connection
SSOConnection.get	`await $.SSOConnection.get({ id: 'sso_connection_1' })`	SSO Connection
SSOConnection.list	`await $.SSOConnection.list({ limit: 20 })`	list of SSO Connection
SSOConnection.update	`await $.SSOConnection.update({ id: 'sso_connection_1', protocol: 'saml' })`	SSO Connection
SSOConnection.activate	`await $.SSOConnection.activate({ connection: 'sso_connection_1' })`	SSO Connection
SSOConnection.deactivate	`await $.SSOConnection.deactivate({ connection: 'sso_connection_1' })`	SSO Connection

Standard

Operation	Call	Resolves to
Standard.get	`await $.Standard.get({ id: 'standard_1' })`	Standard
Standard.list	`await $.Standard.list({ limit: 20 })`	list of Standard

Startup

Operation	Call	Resolves to
Startup.create	`await $.Startup.create({ name: 'Acme' })`	Startup
Startup.get	`await $.Startup.get({ id: 'startup_1' })`	Startup
Startup.list	`await $.Startup.list({ limit: 20 })`	list of Startup
Startup.update	`await $.Startup.update({ id: 'startup_1', name: 'Acme' })`	Startup
Startup.delete	`await $.Startup.delete({ id: 'startup_1' })`	Startup
Startup.advance	`await $.Startup.advance({ startup: 'startup_1' })`	Startup
Startup.build	`await $.Startup.build({ startup: 'startup_1' })`	Startup
Startup.claim	`await $.Startup.claim({ startup: 'startup_1', claimToken: 'Example claim token' })`	Startup
Startup.clone	`await $.Startup.clone({ startup: 'startup_1', name: 'Acme' })`	Startup
Startup.graduate	`await $.Startup.graduate({ startup: 'startup_1', company: 'company_1' })`	Startup
Startup.hold	`await $.Startup.hold({ startup: 'startup_1' })`	Startup
Startup.import	`await $.Startup.import({ source: 'https://acme.com' })`	Startup
Startup.launch	`await $.Startup.launch({ startup: 'startup_1' })`	Startup
Startup.pause	`await $.Startup.pause({ startup: 'startup_1' })`	Startup
Startup.pivot	`await $.Startup.pivot({ startup: 'startup_1', decision: 'decision_1' })`	Startup
Startup.read	`await $.Startup.read({ startup: 'startup_1', scope: 'diligence' })`	`room`: `json`, `gaps`: `json`, `startup`: Startup
Startup.resume	`await $.Startup.resume({ startup: 'startup_1' })`	Startup
Startup.sell	`await $.Startup.sell({ startup: 'startup_1', agreement: 'agreement_1' })`	Startup

Startup Template

Operation	Call	Resolves to
StartupTemplate.create	`await $.StartupTemplate.create({ slug: 'acme', operatingModel: 'autonomous', motions: ['Example motions'] })`	Startup Template
StartupTemplate.get	`await $.StartupTemplate.get({ id: 'startup_template_1' })`	Startup Template
StartupTemplate.list	`await $.StartupTemplate.list({ limit: 20 })`	list of Startup Template
StartupTemplate.update	`await $.StartupTemplate.update({ id: 'startup_template_1', slug: 'acme' })`	Startup Template
StartupTemplate.delete	`await $.StartupTemplate.delete({ id: 'startup_template_1' })`	Startup Template
StartupTemplate.extend	`await $.StartupTemplate.extend({ startupTemplate: 'startup_template_1', startup: 'startup_1' })`	`startup`: Startup, `startupTemplate`: Startup Template
StartupTemplate.promote	`await $.StartupTemplate.promote({ startupTemplate: 'startup_template_1', startup: 'startup_1' })`	`change`: Change, `startupTemplate`: Startup Template
StartupTemplate.upgrade	`await $.StartupTemplate.upgrade({ startupTemplate: 'startup_template_1', startup: 'startup_1' })`	`change`: Change, `startupTemplate`: Startup Template

Statement

Operation	Call	Resolves to
Statement.get	`await $.Statement.get({ id: 'statement_1' })`	Statement
Statement.list	`await $.Statement.list({ limit: 20 })`	list of Statement

Story

Operation	Call	Resolves to
Story.create	`await $.Story.create({ icp: 'icp_1', hero: 'Example hero', problem: 'problem_1', from: 'Hypothesis#approach@v1' })`	Story
Story.get	`await $.Story.get({ id: 'story_1' })`	Story
Story.list	`await $.Story.list({ limit: 20 })`	list of Story
Story.update	`await $.Story.update({ id: 'story_1', icp: 'icp_1' })`	Story
Story.delete	`await $.Story.delete({ id: 'story_1' })`	Story

Studio

Operation	Call	Resolves to
Studio.create	`await $.Studio.create({ name: 'Acme' })`	Studio
Studio.get	`await $.Studio.get({ id: 'studio_1' })`	Studio
Studio.list	`await $.Studio.list({ limit: 20 })`	list of Studio
Studio.update	`await $.Studio.update({ id: 'studio_1', name: 'Acme' })`	Studio
Studio.delete	`await $.Studio.delete({ id: 'studio_1' })`	Studio

Subscription

Operation	Call	Resolves to
Subscription.create	`await $.Subscription.create({ renewsAt: '2026-10-22T12:00:00Z' })`	Subscription
Subscription.get	`await $.Subscription.get({ id: 'subscription_1' })`	Subscription
Subscription.list	`await $.Subscription.list({ limit: 20 })`	list of Subscription
Subscription.update	`await $.Subscription.update({ id: 'subscription_1', renewsAt: '2026-10-22T12:00:00Z' })`	Subscription
Subscription.keep	`await $.Subscription.keep({ subscription: 'subscription_1' })`	Subscription
Subscription.pause	`await $.Subscription.pause({ subscription: 'subscription_1', until: '2026-10-22' })`	Subscription
Subscription.renew	`await $.Subscription.renew({ subscription: 'subscription_1' })`	`invoice`: Invoice, `subscription`: Subscription
Subscription.resize	`await $.Subscription.resize({ subscription: 'subscription_1', quantity: 1 })`	Subscription
Subscription.resume	`await $.Subscription.resume({ subscription: 'subscription_1' })`	Subscription
Subscription.switch	`await $.Subscription.switch({ subscription: 'subscription_1', offer: 'offer_1' })`	Subscription
Subscription.unsubscribe	`await $.Subscription.unsubscribe({ subscription: 'subscription_1' })`	Subscription

Supplier

Operation	Call	Resolves to
Supplier.create	`await $.Supplier.create({ name: 'Acme' })`	Supplier
Supplier.get	`await $.Supplier.get({ id: 'supplier_1' })`	Supplier
Supplier.list	`await $.Supplier.list({ limit: 20 })`	list of Supplier
Supplier.update	`await $.Supplier.update({ id: 'supplier_1', payoutAccount: 'Example payout account' })`	Supplier
Supplier.delete	`await $.Supplier.delete({ id: 'supplier_1' })`	Supplier

Suppression

Operation	Call	Resolves to
Suppression.create	`await $.Suppression.create({ address: 'Example address' })`	Suppression
Suppression.get	`await $.Suppression.get({ id: 'suppression_1' })`	Suppression
Suppression.list	`await $.Suppression.list({ limit: 20 })`	list of Suppression

Survey

Operation	Call	Resolves to
Survey.create	`await $.Survey.create({ fields: {} })`	Survey
Survey.get	`await $.Survey.get({ id: 'survey_1' })`	Survey
Survey.list	`await $.Survey.list({ limit: 20 })`	list of Survey
Survey.update	`await $.Survey.update({ id: 'survey_1', fields: {} })`	Survey
Survey.delete	`await $.Survey.delete({ id: 'survey_1' })`	Survey

System

Operation	Call	Resolves to
System.create	`await $.System.create({ job: 'Example job' })`	System
System.get	`await $.System.get({ id: 'system_1' })`	System
System.list	`await $.System.list({ limit: 20 })`	list of System
System.update	`await $.System.update({ id: 'system_1', job: 'Example job' })`	System
System.delete	`await $.System.delete({ id: 'system_1' })`	System

Task

Operation	Call	Resolves to
Task.create	`await $.Task.create({ by: 'worker_1' })`	Task
Task.get	`await $.Task.get({ id: 'task_1' })`	Task
Task.list	`await $.Task.list({ limit: 20 })`	list of Task
Task.update	`await $.Task.update({ id: 'task_1', due: '2026-10-22T12:00:00Z' })`	Task
Task.delete	`await $.Task.delete({ id: 'task_1' })`	Task
Task.assign	`await $.Task.assign({ task: 'task_1', worker: 'worker_1' })`	Task
Task.claim	`await $.Task.claim({ task: 'task_1' })`	Task
Task.complete	`await $.Task.complete({ task: 'task_1' })`	Task
Task.delegate	`await $.Task.delegate({ task: 'task_1', role: 'role_1' })`	Task
Task.escalate	`await $.Task.escalate({ task: 'task_1', reason: 'Example reason' })`	Task
Task.next	`await $.Task.next()`	Task
Task.return	`await $.Task.return({ task: 'task_1', reason: 'Example reason' })`	Task

Team

Operation	Call	Resolves to
Team.create	`await $.Team.create({ mission: 'Example mission' })`	Team
Team.get	`await $.Team.get({ id: 'team_1' })`	Team
Team.list	`await $.Team.list({ limit: 20 })`	list of Team
Team.update	`await $.Team.update({ id: 'team_1', mission: 'Example mission' })`	Team
Team.delete	`await $.Team.delete({ id: 'team_1' })`	Team

Template

Operation	Call	Resolves to
Template.create	`await $.Template.create({ body: 'Example body' })`	Template
Template.get	`await $.Template.get({ id: 'template_1' })`	Template
Template.list	`await $.Template.list({ limit: 20 })`	list of Template
Template.update	`await $.Template.update({ id: 'template_1', body: 'Example body' })`	Template
Template.delete	`await $.Template.delete({ id: 'template_1' })`	Template
Template.extend	`await $.Template.extend({ template: 'template_1', startup: 'startup_1' })`	`startup`: Startup, `template`: Template
Template.promote	`await $.Template.promote({ template: 'template_1', startup: 'startup_1' })`	`change`: Change, `template`: Template
Template.upgrade	`await $.Template.upgrade({ template: 'template_1', startup: 'startup_1' })`	`change`: Change, `template`: Template

Tenant

Operation	Call	Resolves to
Tenant.create	`await $.Tenant.create({ placement: 'path' })`	Tenant
Tenant.get	`await $.Tenant.get({ id: 'tenant_1' })`	Tenant
Tenant.list	`await $.Tenant.list({ limit: 20 })`	list of Tenant
Tenant.update	`await $.Tenant.update({ id: 'tenant_1', placement: 'path' })`	Tenant
Tenant.delete	`await $.Tenant.delete({ id: 'tenant_1' })`	Tenant
Tenant.invite	`await $.Tenant.invite({ tenant: 'tenant_1', email: 'ada@acme.com' })`	`person`: Person, `tenant`: Tenant
Tenant.pin	`await $.Tenant.pin({ tenant: 'tenant_1', apiVersion: 'v2' })`	Tenant
Tenant.provision	`await $.Tenant.provision({ customer: 'customer_1' })`	Tenant
Tenant.requestSetup	`await $.Tenant.requestSetup({ tenant: 'tenant_1', admin: 'person_1', intent: 'sso' })`	`link`: `url`, `tenant`: Tenant

Theme

Operation	Call	Resolves to
Theme.create	`await $.Theme.create({ tokens: {} })`	Theme
Theme.get	`await $.Theme.get({ id: 'theme_1' })`	Theme
Theme.list	`await $.Theme.list({ limit: 20 })`	list of Theme
Theme.update	`await $.Theme.update({ id: 'theme_1', tokens: {} })`	Theme
Theme.delete	`await $.Theme.delete({ id: 'theme_1' })`	Theme

Thing

Operation	Call	Resolves to
Thing.create	`await $.Thing.create({ id: 'thing_1', type: ['noun_1'] })`	Thing
Thing.get	`await $.Thing.get({ id: 'thing_1' })`	Thing
Thing.list	`await $.Thing.list({ limit: 20 })`	list of Thing
Thing.update	`await $.Thing.update({ id: 'thing_1', type: ['noun_1'] })`	Thing
Thing.delete	`await $.Thing.delete({ id: 'thing_1' })`	Thing
Thing.relate	`await $.Thing.relate({ thing: 'thing_1', predicate: 'Example predicate', to: 'thing_1' })`	`relationship`: Relationship, `thing`: Thing
Thing.resolve	`await $.Thing.resolve({ noun: 'noun_1', match: {} })`	`thing`: Thing, `decision`: `string`
Thing.share	`await $.Thing.share({ thing: 'thing_1', to: 'party_1', verbs: ['Example verbs'] })`	`permission`: Permission, `thing`: Thing
Thing.unrelate	`await $.Thing.unrelate({ thing: 'thing_1', predicate: 'Example predicate', to: 'thing_1' })`	`relationship`: Relationship, `thing`: Thing

Thread

Operation	Call	Resolves to
Thread.create	`await $.Thread.create({ subject: 'Example subject' })`	Thread
Thread.get	`await $.Thread.get({ id: 'thread_1' })`	Thread
Thread.list	`await $.Thread.list({ limit: 20 })`	list of Thread
Thread.update	`await $.Thread.update({ id: 'thread_1', subject: 'Example subject' })`	Thread
Thread.delete	`await $.Thread.delete({ id: 'thread_1' })`	Thread

Tool

Operation	Call	Resolves to
Tool.create	`await $.Tool.create({ name: 'Acme' })`	Tool
Tool.get	`await $.Tool.get({ id: 'tool_1' })`	Tool
Tool.list	`await $.Tool.list({ limit: 20 })`	list of Tool
Tool.update	`await $.Tool.update({ id: 'tool_1', name: 'Acme' })`	Tool
Tool.delete	`await $.Tool.delete({ id: 'tool_1' })`	Tool

Transaction

Operation	Call	Resolves to
Transaction.get	`await $.Transaction.get({ id: 'transaction_1' })`	Transaction
Transaction.list	`await $.Transaction.list({ limit: 20 })`	list of Transaction
Transaction.attach	`await $.Transaction.attach({ transaction: 'transaction_1' })`	Transaction
Transaction.categorize	`await $.Transaction.categorize({ transaction: 'transaction_1' })`	`transaction`: Transaction, `account`: `string`, `confidence`: `number`
Transaction.reconcile	`await $.Transaction.reconcile({ transaction: 'transaction_1' })`	Transaction

Trigger

Operation	Call	Resolves to
Trigger.create	`await $.Trigger.create({ event: 'Example event' })`	Trigger
Trigger.get	`await $.Trigger.get({ id: 'trigger_1' })`	Trigger
Trigger.list	`await $.Trigger.list({ limit: 20 })`	list of Trigger
Trigger.update	`await $.Trigger.update({ id: 'trigger_1', threshold: {} })`	Trigger
Trigger.delete	`await $.Trigger.delete({ id: 'trigger_1' })`	Trigger

Variant

Operation	Call	Resolves to
Variant.create	`await $.Variant.create({ key: 'Example key', value: {} })`	Variant
Variant.get	`await $.Variant.get({ id: 'variant_1' })`	Variant
Variant.list	`await $.Variant.list({ limit: 20 })`	list of Variant
Variant.update	`await $.Variant.update({ id: 'variant_1', value: {} })`	Variant
Variant.delete	`await $.Variant.delete({ id: 'variant_1' })`	Variant

Verb

Operation	Call	Resolves to
Verb.create	`await $.Verb.create({ name: 'Acme', event: 'Example event' })`	Verb
Verb.get	`await $.Verb.get({ id: 'verb_1' })`	Verb
Verb.list	`await $.Verb.list({ limit: 20 })`	list of Verb
Verb.update	`await $.Verb.update({ id: 'verb_1', name: 'Acme' })`	Verb
Verb.delete	`await $.Verb.delete({ id: 'verb_1' })`	Verb
Verb.retire	`await $.Verb.retire({ verb: 'verb_1' })`	`version`: Version, `verb`: Verb

Version

Operation	Call	Resolves to
Version.get	`await $.Version.get({ id: 'version_1' })`	Version
Version.list	`await $.Version.list({ limit: 20 })`	list of Version
Version.deploy	`await $.Version.deploy({ version: 'version_1' })`	Version

Video

Operation	Call	Resolves to
Video.create	`await $.Video.create({ timeline: {}, brand: 'brand_1' })`	Video
Video.get	`await $.Video.get({ id: 'video_1' })`	Video
Video.list	`await $.Video.list({ limit: 20 })`	list of Video
Video.update	`await $.Video.update({ id: 'video_1', timeline: {} })`	Video
Video.draft	`await $.Video.draft({ brand: 'brand_1' })`	Video
Video.finalize	`await $.Video.finalize({ video: 'video_1' })`	Video

Visit

Operation	Call	Resolves to
Visit.get	`await $.Visit.get({ id: 'visit_1' })`	Visit
Visit.list	`await $.Visit.list({ limit: 20 })`	list of Visit

Visitor

Operation	Call	Resolves to
Visitor.create	`await $.Visitor.create({ firstSeenAt: '2026-10-22T12:00:00Z' })`	Visitor
Visitor.get	`await $.Visitor.get({ id: 'visitor_1' })`	Visitor
Visitor.list	`await $.Visitor.list({ limit: 20 })`	list of Visitor
Visitor.update	`await $.Visitor.update({ id: 'visitor_1', firstSeenAt: '2026-10-22T12:00:00Z' })`	Visitor
Visitor.delete	`await $.Visitor.delete({ id: 'visitor_1' })`	Visitor
Visitor.forget	`await $.Visitor.forget({ visitor: 'visitor_1', request: 'Example request' })`	Visitor
Visitor.identify	`await $.Visitor.identify({ visitor: 'visitor_1', contact: 'contact_1' })`	`contact`: Contact, `visitor`: Visitor
Visitor.merge	`await $.Visitor.merge({ visitor: 'visitor_1', into: 'visitor_1' })`	Visitor

Voice

Operation	Call	Resolves to
Voice.get	`await $.Voice.get({ id: 'voice_1' })`	Voice
Voice.list	`await $.Voice.list({ limit: 20 })`	list of Voice
Voice.update	`await $.Voice.update({ id: 'voice_1', origin: 'cloned' })`	Voice
Voice.clone	`await $.Voice.clone({ speaker: 'person_1', samples: ['file_1'], consent: 'consent_1', scope: 'studio' })`	Voice
Voice.retire	`await $.Voice.retire({ voice: 'voice_1' })`	Voice

Waitlist

Operation	Call	Resolves to
Waitlist.create	`await $.Waitlist.create({ invited: 1 })`	Waitlist
Waitlist.get	`await $.Waitlist.get({ id: 'waitlist_1' })`	Waitlist
Waitlist.list	`await $.Waitlist.list({ limit: 20 })`	list of Waitlist
Waitlist.update	`await $.Waitlist.update({ id: 'waitlist_1', invited: 1 })`	Waitlist
Waitlist.delete	`await $.Waitlist.delete({ id: 'waitlist_1' })`	Waitlist
Waitlist.admit	`await $.Waitlist.admit({ waitlist: 'waitlist_1', count: 1 })`	`leads`: list of Lead, `waitlist`: Waitlist
Waitlist.join	`await $.Waitlist.join({ waitlist: 'waitlist_1', email: 'ada@acme.com' })`	`lead`: Lead, `waitlist`: Waitlist

Watch

Operation	Call	Resolves to
Watch.create	`await $.Watch.create({ selector: 'Example selector', url: 'https://acme.com' })`	`watch`: Watch, `secret`: `string`
Watch.get	`await $.Watch.get({ id: 'watch_1' })`	Watch
Watch.list	`await $.Watch.list({ limit: 20 })`	list of Watch
Watch.update	`await $.Watch.update({ id: 'watch_1', url: 'https://acme.com' })`	Watch
Watch.delete	`await $.Watch.delete({ id: 'watch_1' })`	Watch
Watch.pause	`await $.Watch.pause({ watch: 'watch_1' })`	Watch
Watch.replay	`await $.Watch.replay({ watch: 'watch_1', from: '2026-10-22T12:00:00Z' })`	Watch
Watch.resume	`await $.Watch.resume({ watch: 'watch_1' })`	Watch
Watch.rotate	`await $.Watch.rotate({ watch: 'watch_1' })`	`watch`: Watch, `secret`: `string`

Worker

Operation	Call	Resolves to
Worker.create	`await $.Worker.create({ name: 'Acme' })`	Worker
Worker.get	`await $.Worker.get({ id: 'worker_1' })`	Worker
Worker.list	`await $.Worker.list({ limit: 20 })`	list of Worker
Worker.update	`await $.Worker.update({ id: 'worker_1', name: 'Acme' })`	Worker
Worker.delete	`await $.Worker.delete({ id: 'worker_1' })`	Worker

Workflow

Operation	Call	Resolves to
Workflow.create	`await $.Workflow.create({ steps: {} })`	Workflow
Workflow.get	`await $.Workflow.get({ id: 'workflow_1' })`	Workflow
Workflow.list	`await $.Workflow.list({ limit: 20 })`	list of Workflow
Workflow.update	`await $.Workflow.update({ id: 'workflow_1', steps: {} })`	Workflow
Workflow.delete	`await $.Workflow.delete({ id: 'workflow_1' })`	Workflow

GrammarCopy Anchor Link

Access LevelCopy Anchor Link

AccountCopy Anchor Link

AcquisitionCopy Anchor Link

ActionCopy Anchor Link

AdCopy Anchor Link

AgentCopy Anchor Link

AgreementCopy Anchor Link

API KeyCopy Anchor Link

AppCopy Anchor Link

ApprovalCopy Anchor Link

AttestationCopy Anchor Link

AudienceCopy Anchor Link

AuditCopy Anchor Link

BillCopy Anchor Link

BrandCopy Anchor Link

BudgetCopy Anchor Link

BuilderCopy Anchor Link

CampaignCopy Anchor Link

CandidateCopy Anchor Link

CapabilityCopy Anchor Link

Capital CallCopy Anchor Link

Capital CommitmentCopy Anchor Link

CardCopy Anchor Link

ChangeCopy Anchor Link

ChannelCopy Anchor Link

CohortCopy Anchor Link

CollectionCopy Anchor Link

CommentCopy Anchor Link

CommissionCopy Anchor Link

CompanyCopy Anchor Link

ComponentCopy Anchor Link

ConsentCopy Anchor Link

ContactCopy Anchor Link

ContentCopy Anchor Link

ControlCopy Anchor Link

ConversationCopy Anchor Link

CostCopy Anchor Link

CouponCopy Anchor Link

CredentialCopy Anchor Link

Credit GrantCopy Anchor Link

CriterionCopy Anchor Link

CustomerCopy Anchor Link

DashboardCopy Anchor Link

DatasetCopy Anchor Link

DealCopy Anchor Link

DecisionCopy Anchor Link

Demand BudgetCopy Anchor Link

DisputeCopy Anchor Link

DNS RecordCopy Anchor Link

DocumentCopy Anchor Link

DomainCopy Anchor Link

EnrollmentCopy Anchor Link

EntitlementCopy Anchor Link

EntryCopy Anchor Link

EvaluatorCopy Anchor Link

EventCopy Anchor Link

EvidenceCopy Anchor Link

ExperimentCopy Anchor Link

ExposureCopy Anchor Link

FileCopy Anchor Link

FlagCopy Anchor Link

FlowCopy Anchor Link

ForecastCopy Anchor Link

FormCopy Anchor Link

FunctionCopy Anchor Link

FundCopy Anchor Link

Fund DistributionCopy Anchor Link

FunnelCopy Anchor Link

GatheringCopy Anchor Link

GoalCopy Anchor Link

GuardCopy Anchor Link

HandleCopy Anchor Link

HolderCopy Anchor Link

HumanCopy Anchor Link

HypothesisCopy Anchor Link

ICPCopy Anchor Link

IdeaCopy Anchor Link

ImplementationCopy Anchor Link

IncidentCopy Anchor Link

Grammar

Access Level

Account

Acquisition

Action

Ad

Agent

Agreement

API Key

App

Approval

Attestation

Audience

Audit

Bill

Brand

Budget

Builder

Campaign

Candidate

Capability

Capital Call

Capital Commitment

Card

Change

Channel

Cohort

Collection

Comment

Commission

Company

Component

Consent

Contact

Content

Control

Conversation

Cost

Coupon

Credential

Credit Grant

Criterion

Customer

Dashboard

Dataset

Deal

Decision

Demand Budget

Dispute

DNS Record

Document

Domain

Enrollment

Entitlement

Entry

Evaluator

Event

Evidence

Experiment

Exposure

File

Flag

Flow

Forecast

Form

Function

Fund

Fund Distribution

Funnel

Gathering

Goal

Guard

Handle

Holder

Human

Hypothesis

ICP

Idea

Implementation

Incident