MCP programs · StartupBuilder

Every Verb on every Noun as a one-line do program for the api.sb MCP server.

Grammar

JSON

{
  "name": "do",
  "arguments": {
    "code": "return await $.Noun.verb(input)"
  }
}

The MCP spec covers authentication, Modes, and errors.

Access Level

Operation	do program
AccessLevel.get	`return await $.AccessLevel.get({ id: 'access_level_1' })`
AccessLevel.list	`return await $.AccessLevel.list({ limit: 20 })`

Account

Operation	do program
Account.get	`return await $.Account.get({ id: 'account_1' })`
Account.list	`return await $.Account.list({ limit: 20 })`
Account.payout	`return await $.Account.payout({ account: 'account_1' })`
Account.sweep	`return await $.Account.sweep({ from: 'account_1', to: 'account_1' })`

Acquisition

Operation	do program
Acquisition.get	`return await $.Acquisition.get({ id: 'acquisition_1' })`
Acquisition.list	`return await $.Acquisition.list({ limit: 20 })`

Action

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

Operation	do program
Ad.create	`return await $.Ad.create({ format: 'search' })`
Ad.get	`return await $.Ad.get({ id: 'ad_1' })`
Ad.list	`return await $.Ad.list({ limit: 20 })`
Ad.update	`return await $.Ad.update({ id: 'ad_1', format: 'search' })`
Ad.delete	`return await $.Ad.delete({ id: 'ad_1' })`

Agent

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

Agreement

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

API Key

Operation	do program
APIKey.get	`return await $.APIKey.get({ id: 'api_key_1' })`
APIKey.list	`return await $.APIKey.list({ limit: 20 })`
APIKey.issue	`return await $.APIKey.issue({ customer: 'customer_1', name: 'Nightly sync', environment: 'test' })`
APIKey.revoke	`return await $.APIKey.revoke({ apiKey: 'api_key_1' })`
APIKey.roll	`return await $.APIKey.roll({ apiKey: 'api_key_1' })`

App

Operation	do program
App.publish	`return await $.App.publish({ app: 'app_1' })`

Approval

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

Attestation

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

Audience

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

Audit

Operation	do program
Audit.get	`return await $.Audit.get({ id: 'audit_1' })`
Audit.list	`return await $.Audit.list({ limit: 20 })`

Bill

Operation	do program
Bill.create	`return await $.Bill.create({ organization: 'organization_1', amount: { amount: 49, currency: 'USD' }, dueOn: '2026-10-22' })`
Bill.get	`return await $.Bill.get({ id: 'bill_1' })`
Bill.list	`return await $.Bill.list({ limit: 20 })`
Bill.update	`return await $.Bill.update({ id: 'bill_1', organization: 'organization_1' })`
Bill.approve	`return await $.Bill.approve({ bill: 'bill_1' })`
Bill.pay	`return await $.Bill.pay({ bill: 'bill_1' })`

Brand

Operation	do program
Brand.create	`return await $.Brand.create({ name: 'Acme' })`
Brand.get	`return await $.Brand.get({ id: 'brand_1' })`
Brand.list	`return await $.Brand.list({ limit: 20 })`
Brand.update	`return await $.Brand.update({ id: 'brand_1', name: 'Acme' })`
Brand.delete	`return await $.Brand.delete({ id: 'brand_1' })`
Brand.clear	`return await $.Brand.clear({ brand: 'brand_1' })`

Budget

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

Builder

Operation	do program
Builder.get	`return await $.Builder.get({ id: 'builder_1' })`
Builder.list	`return await $.Builder.list({ limit: 20 })`

Campaign

Operation	do program
Campaign.create	`return await $.Campaign.create({ budget: { amount: 49, currency: 'USD' } })`
Campaign.get	`return await $.Campaign.get({ id: 'campaign_1' })`
Campaign.list	`return await $.Campaign.list({ limit: 20 })`
Campaign.update	`return await $.Campaign.update({ id: 'campaign_1', budget: { amount: 49, currency: 'USD' } })`
Campaign.delete	`return await $.Campaign.delete({ id: 'campaign_1' })`

Candidate

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

Capability

Operation	do program
Capability.get	`return await $.Capability.get({ id: 'capability_1' })`
Capability.list	`return await $.Capability.list({ limit: 20 })`

Capital Call

Operation	do program
CapitalCall.get	`return await $.CapitalCall.get({ id: 'capital_call_1' })`
CapitalCall.list	`return await $.CapitalCall.list({ limit: 20 })`

Capital Commitment

Operation	do program
CapitalCommitment.create	`return await $.CapitalCommitment.create({ investor: 'party_1', amount: { amount: 49, currency: 'USD' } })`
CapitalCommitment.get	`return await $.CapitalCommitment.get({ id: 'capital_commitment_1' })`
CapitalCommitment.list	`return await $.CapitalCommitment.list({ limit: 20 })`
CapitalCommitment.update	`return await $.CapitalCommitment.update({ id: 'capital_commitment_1', investor: 'party_1' })`
CapitalCommitment.countersign	`return await $.CapitalCommitment.countersign({ commitment: 'capital_commitment_1', agreement: 'agreement_1' })`

Card

Operation	do program
Card.get	`return await $.Card.get({ id: 'card_1' })`
Card.list	`return await $.Card.list({ limit: 20 })`
Card.issue	`return await $.Card.issue({ mandate: 'mandate_1', form: 'singleUse' })`

Change

Operation	do program
Change.create	`return await $.Change.create({ base: 'version_1' })`
Change.get	`return await $.Change.get({ id: 'change_1' })`
Change.list	`return await $.Change.list({ limit: 20 })`
Change.merge	`return await $.Change.merge({ change: 'change_1' })`
Change.revert	`return await $.Change.revert({ change: 'change_1', reason: 'Example reason' })`
Change.review	`return await $.Change.review({ change: 'change_1' })`

Channel

Operation	do program
Channel.create	`return await $.Channel.create({ medium: 'email' })`
Channel.get	`return await $.Channel.get({ id: 'channel_1' })`
Channel.list	`return await $.Channel.list({ limit: 20 })`
Channel.update	`return await $.Channel.update({ id: 'channel_1', medium: 'email' })`
Channel.delete	`return await $.Channel.delete({ id: 'channel_1' })`

Cohort

Operation	do program
Cohort.create	`return await $.Cohort.create({ query: {} })`
Cohort.get	`return await $.Cohort.get({ id: 'cohort_1' })`
Cohort.list	`return await $.Cohort.list({ limit: 20 })`
Cohort.update	`return await $.Cohort.update({ id: 'cohort_1', query: {} })`
Cohort.delete	`return await $.Cohort.delete({ id: 'cohort_1' })`

Collection

Operation	do program
Collection.create	`return await $.Collection.create({ id: 'collection_1', type: ['noun_1'] })`
Collection.get	`return await $.Collection.get({ id: 'collection_1' })`
Collection.list	`return await $.Collection.list({ limit: 20 })`
Collection.update	`return await $.Collection.update({ id: 'collection_1', query: {} })`
Collection.delete	`return await $.Collection.delete({ id: 'collection_1' })`
Collection.export	`return await $.Collection.export({ collection: 'collection_1', to: 'Example to' })`
Collection.query	`return await $.Collection.query({ query: 'Example query' })`

Comment

Operation	do program
Comment.create	`return await $.Comment.create({ body: 'Example body' })`
Comment.get	`return await $.Comment.get({ id: 'comment_1' })`
Comment.list	`return await $.Comment.list({ limit: 20 })`
Comment.update	`return await $.Comment.update({ id: 'comment_1', body: 'Example body' })`
Comment.delete	`return await $.Comment.delete({ id: 'comment_1' })`

Commission

Operation	do program
Commission.create	`return await $.Commission.create({ rate: 1, term: 1, clawbackDays: 1 })`
Commission.get	`return await $.Commission.get({ id: 'commission_1' })`
Commission.list	`return await $.Commission.list({ limit: 20 })`
Commission.update	`return await $.Commission.update({ id: 'commission_1', rate: 1 })`
Commission.pay	`return await $.Commission.pay({ commission: 'commission_1' })`

Company

Operation	do program
Company.create	`return await $.Company.create({ name: 'Acme', legalName: 'Acme Inc.', jurisdiction: 'US-DE' })`
Company.get	`return await $.Company.get({ id: 'company_1' })`
Company.list	`return await $.Company.list({ limit: 20 })`
Company.update	`return await $.Company.update({ id: 'company_1', legalName: 'Acme Inc.' })`
Company.dissolve	`return await $.Company.dissolve({ company: 'company_1', reason: 'Example reason' })`
Company.incorporate	`return await $.Company.incorporate({ legalName: 'Acme Inc.', jurisdiction: 'US-DE' })`
Company.register	`return await $.Company.register({ jurisdiction: 'US-TX', kind: 'salesTax' })`
Company.submit	`return await $.Company.submit({ jurisdiction: 'US-TX', kind: 'salesTax', periods: ['period_1'] })`

Component

Operation	do program
Component.create	`return await $.Component.create({ name: 'Acme', props: {} })`
Component.get	`return await $.Component.get({ id: 'component_1' })`
Component.list	`return await $.Component.list({ limit: 20 })`
Component.update	`return await $.Component.update({ id: 'component_1', name: 'Acme' })`
Component.delete	`return await $.Component.delete({ id: 'component_1' })`

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

Contact

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

Content

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

Control

Operation	do program
Control.get	`return await $.Control.get({ id: 'control_1' })`
Control.list	`return await $.Control.list({ limit: 20 })`

Conversation

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

Cost

Operation	do program
Cost.get	`return await $.Cost.get({ id: 'cost_1' })`
Cost.list	`return await $.Cost.list({ limit: 20 })`

Coupon

Operation	do program
Coupon.create	`return await $.Coupon.create({ duration: 'once' })`
Coupon.get	`return await $.Coupon.get({ id: 'coupon_1' })`
Coupon.list	`return await $.Coupon.list({ limit: 20 })`
Coupon.update	`return await $.Coupon.update({ id: 'coupon_1', percentOff: 1 })`

Credential

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

Credit Grant

Operation	do program
CreditGrant.create	`return await $.CreditGrant.create({ amount: { amount: 49, currency: 'USD' }, category: 'paid' })`
CreditGrant.get	`return await $.CreditGrant.get({ id: 'credit_grant_1' })`
CreditGrant.list	`return await $.CreditGrant.list({ limit: 20 })`
CreditGrant.apply	`return await $.CreditGrant.apply({ invoice: 'invoice_1' })`
CreditGrant.issue	`return await $.CreditGrant.issue({ customer: 'customer_1', amount: { amount: 49, currency: 'USD' }, category: 'paid' })`
CreditGrant.void	`return await $.CreditGrant.void({ creditGrant: 'credit_grant_1', reason: 'Example reason' })`

Criterion

Operation	do program
Criterion.get	`return await $.Criterion.get({ id: 'criterion_1' })`
Criterion.list	`return await $.Criterion.list({ limit: 20 })`

Customer

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

Dashboard

Operation	do program
Dashboard.create	`return await $.Dashboard.create({ scope: 'Startup' })`
Dashboard.get	`return await $.Dashboard.get({ id: 'dashboard_1' })`
Dashboard.list	`return await $.Dashboard.list({ limit: 20 })`
Dashboard.update	`return await $.Dashboard.update({ id: 'dashboard_1', scope: 'Startup' })`
Dashboard.delete	`return await $.Dashboard.delete({ id: 'dashboard_1' })`
Dashboard.ask	`return await $.Dashboard.ask({ question: 'Example question' })`
Dashboard.schedule	`return await $.Dashboard.schedule({ dashboard: 'dashboard_1', cadence: 'daily', to: 'Example to' })`

Dataset

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

Deal

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

Decision

Operation	do program
Decision.create	`return await $.Decision.create({ choice: 'Example choice', reason: 'Example reason' })`
Decision.get	`return await $.Decision.get({ id: 'decision_1' })`
Decision.list	`return await $.Decision.list({ limit: 20 })`
Decision.supersede	`return await $.Decision.supersede({ decision: 'decision_1', by: 'decision_1' })`

Demand Budget

Operation	do program
DemandBudget.create	`return await $.DemandBudget.create({ amount: { amount: 49, currency: 'USD' }, tier: '$0', target: 'Example target', stopRule: 'Example stop rule' })`
DemandBudget.get	`return await $.DemandBudget.get({ id: 'demand_budget_1' })`
DemandBudget.list	`return await $.DemandBudget.list({ limit: 20 })`
DemandBudget.update	`return await $.DemandBudget.update({ id: 'demand_budget_1', amount: { amount: 49, currency: 'USD' } })`

Dispute

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

DNS Record

Operation	do program
DNSRecord.get	`return await $.DNSRecord.get({ id: 'dns_record_1' })`
DNSRecord.list	`return await $.DNSRecord.list({ limit: 20 })`
DNSRecord.remove	`return await $.DNSRecord.remove({ record: 'dns_record_1' })`
DNSRecord.set	`return await $.DNSRecord.set({ domain: 'domain_1', type: 'a', name: 'Acme', value: 'Example value' })`

Document

Operation	do program
Document.create	`return await $.Document.create({ form: 'document' })`
Document.get	`return await $.Document.get({ id: 'document_1' })`
Document.list	`return await $.Document.list({ limit: 20 })`
Document.update	`return await $.Document.update({ id: 'document_1', form: 'document' })`
Document.delete	`return await $.Document.delete({ id: 'document_1' })`
Document.render	`return await $.Document.render({ document: 'document_1', format: 'Example format' })`

Domain

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

Enrollment

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

Entitlement

Operation	do program
Entitlement.create	`return await $.Entitlement.create({ verb: 'verb_1' })`
Entitlement.get	`return await $.Entitlement.get({ id: 'entitlement_1' })`
Entitlement.list	`return await $.Entitlement.list({ limit: 20 })`
Entitlement.update	`return await $.Entitlement.update({ id: 'entitlement_1', verb: 'verb_1' })`
Entitlement.delete	`return await $.Entitlement.delete({ id: 'entitlement_1' })`
Entitlement.check	`return await $.Entitlement.check({ customer: 'customer_1', verb: 'verb_1' })`

Entry

Operation	do program
Entry.get	`return await $.Entry.get({ id: 'entry_1' })`
Entry.list	`return await $.Entry.list({ limit: 20 })`
Entry.post	`return await $.Entry.post({ debit: 'Example debit', credit: 'Example credit', amount: { amount: 49, currency: 'USD' }, memo: 'Example memo' })`
Entry.settle	`return await $.Entry.settle({ period: 'period_1', from: 'company_1', to: 'company_1' })`

Evaluator

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

Event

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

Evidence

Operation	do program
Evidence.create	`return await $.Evidence.create({ grade: 'Behavior' })`
Evidence.get	`return await $.Evidence.get({ id: 'evidence_1' })`
Evidence.list	`return await $.Evidence.list({ limit: 20 })`

Experiment

Operation	do program
Experiment.create	`return await $.Experiment.create({ variants: {} })`
Experiment.get	`return await $.Experiment.get({ id: 'experiment_1' })`
Experiment.list	`return await $.Experiment.list({ limit: 20 })`
Experiment.conclude	`return await $.Experiment.conclude({ experiment: 'experiment_1', decision: 'ship' })`
Experiment.start	`return await $.Experiment.start({ experiment: 'experiment_1' })`

Exposure

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

File

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

Flag

Operation	do program
Flag.create	`return await $.Flag.create({ key: 'new-checkout' })`
Flag.get	`return await $.Flag.get({ id: 'flag_1' })`
Flag.list	`return await $.Flag.list({ limit: 20 })`
Flag.update	`return await $.Flag.update({ id: 'flag_1', key: 'new-checkout' })`
Flag.delete	`return await $.Flag.delete({ id: 'flag_1' })`
Flag.evaluate	`return await $.Flag.evaluate({ flag: 'flag_1', unit: 'Example unit' })`

Flow

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

Forecast

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

Form

Operation	do program
Form.create	`return await $.Form.create({ fields: {} })`
Form.get	`return await $.Form.get({ id: 'form_1' })`
Form.list	`return await $.Form.list({ limit: 20 })`
Form.update	`return await $.Form.update({ id: 'form_1', fields: {} })`
Form.delete	`return await $.Form.delete({ id: 'form_1' })`

Function

Operation	do program
Function.create	`return await $.Function.create({ kind: 'code' })`
Function.get	`return await $.Function.get({ id: 'function_1' })`
Function.list	`return await $.Function.list({ limit: 20 })`
Function.update	`return await $.Function.update({ id: 'function_1', kind: 'code' })`
Function.delete	`return await $.Function.delete({ id: 'function_1' })`

Fund

Operation	do program
Fund.create	`return await $.Fund.create({ name: 'Acme' })`
Fund.get	`return await $.Fund.get({ id: 'fund_1' })`
Fund.list	`return await $.Fund.list({ limit: 20 })`
Fund.update	`return await $.Fund.update({ id: 'fund_1', name: 'Acme' })`
Fund.delete	`return await $.Fund.delete({ id: 'fund_1' })`
Fund.call	`return await $.Fund.call({ fund: 'fund_1', amount: { amount: 49, currency: 'USD' }, dueOn: '2026-10-22', purpose: 'Example purpose' })`
Fund.distribute	`return await $.Fund.distribute({ fund: 'fund_1', amount: { amount: 49, currency: 'USD' }, kind: 'cash' })`
Fund.report	`return await $.Fund.report({ fund: 'fund_1', period: 'period_1' })`

Fund Distribution

Operation	do program
FundDistribution.get	`return await $.FundDistribution.get({ id: 'fund_distribution_1' })`
FundDistribution.list	`return await $.FundDistribution.list({ limit: 20 })`

Funnel

Operation	do program
Funnel.create	`return await $.Funnel.create({ steps: {} })`
Funnel.get	`return await $.Funnel.get({ id: 'funnel_1' })`
Funnel.list	`return await $.Funnel.list({ limit: 20 })`
Funnel.update	`return await $.Funnel.update({ id: 'funnel_1', steps: {} })`
Funnel.delete	`return await $.Funnel.delete({ id: 'funnel_1' })`

Gathering

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

Goal

Operation	do program
Goal.create	`return await $.Goal.create({ objective: 'Example objective' })`
Goal.get	`return await $.Goal.get({ id: 'goal_1' })`
Goal.list	`return await $.Goal.list({ limit: 20 })`
Goal.update	`return await $.Goal.update({ id: 'goal_1', horizon: 'day' })`
Goal.delete	`return await $.Goal.delete({ id: 'goal_1' })`

Guard

Operation	do program
Guard.create	`return await $.Guard.create({ tier: 'code' })`
Guard.get	`return await $.Guard.get({ id: 'guard_1' })`
Guard.list	`return await $.Guard.list({ limit: 20 })`
Guard.update	`return await $.Guard.update({ id: 'guard_1', tier: 'code' })`
Guard.delete	`return await $.Guard.delete({ id: 'guard_1' })`

Handle

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

Holder

Operation	do program
Holder.create	`return await $.Holder.create({ party: 'party_1' })`
Holder.get	`return await $.Holder.get({ id: 'holder_1' })`
Holder.list	`return await $.Holder.list({ limit: 20 })`
Holder.update	`return await $.Holder.update({ id: 'holder_1', party: 'party_1' })`

Human

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

Hypothesis

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

ICP

Operation	do program
ICP.create	`return await $.ICP.create({ description: 'The first Offer.' })`
ICP.get	`return await $.ICP.get({ id: 'icp_1' })`
ICP.list	`return await $.ICP.list({ limit: 20 })`
ICP.update	`return await $.ICP.update({ id: 'icp_1', description: 'The first Offer.' })`
ICP.delete	`return await $.ICP.delete({ id: 'icp_1' })`

Idea

Operation	do program
Idea.create	`return await $.Idea.create({ statement: 'Drafts patents for solo inventors.' })`
Idea.get	`return await $.Idea.get({ id: 'idea_1' })`
Idea.list	`return await $.Idea.list({ limit: 20 })`
Idea.pursue	`return await $.Idea.pursue({ idea: 'idea_1' })`

Implementation

Operation	do program
Implementation.create	`return await $.Implementation.create({ kind: 'managed' })`
Implementation.get	`return await $.Implementation.get({ id: 'implementation_1' })`
Implementation.list	`return await $.Implementation.list({ limit: 20 })`
Implementation.update	`return await $.Implementation.update({ id: 'implementation_1', kind: 'managed' })`
Implementation.delete	`return await $.Implementation.delete({ id: 'implementation_1' })`

Incident

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

Instrument

Operation	do program
Instrument.get	`return await $.Instrument.get({ id: 'instrument_1' })`
Instrument.list	`return await $.Instrument.list({ limit: 20 })`
Instrument.cancel	`return await $.Instrument.cancel({ instrument: 'instrument_1', reason: 'unvested' })`
Instrument.convert	`return await $.Instrument.convert({ instrument: 'instrument_1', roundPrice: { amount: 49, currency: 'USD' } })`
Instrument.exercise	`return await $.Instrument.exercise({ instrument: 'instrument_1', quantity: 1 })`
Instrument.grant	`return await $.Instrument.grant({ holder: 'holder_1', quantity: 1, strike: { amount: 49, currency: 'USD' }, vesting: {} })`

Integration

Operation	do program
Integration.create	`return await $.Integration.create({ acquired: 'owned', scope: 'studio', mode: 'mirror' })`
Integration.get	`return await $.Integration.get({ id: 'integration_1' })`
Integration.list	`return await $.Integration.list({ limit: 20 })`
Integration.update	`return await $.Integration.update({ id: 'integration_1', scope: 'studio' })`
Integration.delete	`return await $.Integration.delete({ id: 'integration_1' })`
Integration.call	`return await $.Integration.call({ integration: 'integration_1', method: 'GET', path: '/' })`
Integration.connect	`return await $.Integration.connect({ system: 'system_1', scope: 'studio', grants: ['Example grants'] })`
Integration.pause	`return await $.Integration.pause({ integration: 'integration_1' })`
Integration.reconnect	`return await $.Integration.reconnect({ integration: 'integration_1' })`
Integration.refresh	`return await $.Integration.refresh({ integration: 'integration_1' })`
Integration.resume	`return await $.Integration.resume({ integration: 'integration_1' })`
Integration.revoke	`return await $.Integration.revoke({ integration: 'integration_1' })`
Integration.sync	`return await $.Integration.sync({ integration: 'integration_1' })`

Interface

Operation	do program
Interface.create	`return await $.Interface.create({ kind: 'api' })`
Interface.get	`return await $.Interface.get({ id: 'interface_1' })`
Interface.list	`return await $.Interface.list({ limit: 20 })`
Interface.update	`return await $.Interface.update({ id: 'interface_1', kind: 'api' })`
Interface.delete	`return await $.Interface.delete({ id: 'interface_1' })`

Interview

Operation	do program
Interview.create	`return await $.Interview.create({ script: 'template_1' })`
Interview.get	`return await $.Interview.get({ id: 'interview_1' })`
Interview.list	`return await $.Interview.list({ limit: 20 })`

Invoice

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

Issue

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

Key Result

Operation	do program
KeyResult.create	`return await $.KeyResult.create({ baseline: 1, target: 1, deadline: '2026-10-22' })`
KeyResult.get	`return await $.KeyResult.get({ id: 'key_result_1' })`
KeyResult.list	`return await $.KeyResult.list({ limit: 20 })`
KeyResult.update	`return await $.KeyResult.update({ id: 'key_result_1', baseline: 1 })`
KeyResult.delete	`return await $.KeyResult.delete({ id: 'key_result_1' })`

Keyword

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

Lead

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

Lifecycle

Operation	do program
Lifecycle.get	`return await $.Lifecycle.get({ id: 'lifecycle_1' })`
Lifecycle.list	`return await $.Lifecycle.list({ limit: 20 })`
Lifecycle.update	`return await $.Lifecycle.update({ id: 'lifecycle_1', states: ['Example states'] })`

Limit

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

Mailbox

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

Mandate

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

Mapping

Operation	do program
Mapping.create	`return await $.Mapping.create({ verb: 'Meeting.book' })`
Mapping.get	`return await $.Mapping.get({ id: 'mapping_1' })`
Mapping.list	`return await $.Mapping.list({ limit: 20 })`
Mapping.update	`return await $.Mapping.update({ id: 'mapping_1', verb: 'Meeting.book' })`
Mapping.delete	`return await $.Mapping.delete({ id: 'mapping_1' })`

Market

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

Meeting

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

Member Directory

Operation	do program
MemberDirectory.create	`return await $.MemberDirectory.create({ groupRoles: {} })`
MemberDirectory.get	`return await $.MemberDirectory.get({ id: 'member_directory_1' })`
MemberDirectory.list	`return await $.MemberDirectory.list({ limit: 20 })`
MemberDirectory.update	`return await $.MemberDirectory.update({ id: 'member_directory_1', groupRoles: {} })`
MemberDirectory.deactivate	`return await $.MemberDirectory.deactivate({ directory: 'member_directory_1' })`
MemberDirectory.deprovision	`return await $.MemberDirectory.deprovision({ directory: 'member_directory_1', person: 'person_1' })`
MemberDirectory.provision	`return await $.MemberDirectory.provision({ tenant: 'tenant_1' })`

Memory

Operation	do program
Memory.create	`return await $.Memory.create({ id: 'memory_1', type: ['noun_1'] })`
Memory.get	`return await $.Memory.get({ id: 'memory_1' })`
Memory.list	`return await $.Memory.list({ limit: 20 })`
Memory.update	`return await $.Memory.update({ id: 'memory_1', type: ['noun_1'] })`
Memory.delete	`return await $.Memory.delete({ id: 'memory_1' })`

Message

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

Meter

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

Metric

Operation	do program
Metric.create	`return await $.Metric.create({ query: 'Example query' })`
Metric.get	`return await $.Metric.get({ id: 'metric_1' })`
Metric.list	`return await $.Metric.list({ limit: 20 })`
Metric.update	`return await $.Metric.update({ id: 'metric_1', query: 'Example query' })`
Metric.delete	`return await $.Metric.delete({ id: 'metric_1' })`
Metric.define	`return await $.Metric.define({ name: 'Acme', query: 'Example query', unit: 'Example unit' })`
Metric.query	`return await $.Metric.query({ shape: 'trend' })`
Metric.watch	`return await $.Metric.watch({ metric: 'metric_1', threshold: 1, direction: 'above' })`

Minimum Success Criteria

Operation	do program
MinimumSuccessCriteria.create	`return await $.MinimumSuccessCriteria.create({ objective: 'Example objective', metric: 'metric_1', value: 1, by: '2026-10-22' })`
MinimumSuccessCriteria.get	`return await $.MinimumSuccessCriteria.get({ id: 'minimum_success_criteria_1' })`
MinimumSuccessCriteria.list	`return await $.MinimumSuccessCriteria.list({ limit: 20 })`
MinimumSuccessCriteria.update	`return await $.MinimumSuccessCriteria.update({ id: 'minimum_success_criteria_1', metric: 'metric_1' })`
MinimumSuccessCriteria.delete	`return await $.MinimumSuccessCriteria.delete({ id: 'minimum_success_criteria_1' })`

Mode

Operation	do program
Mode.get	`return await $.Mode.get({ id: 'mode_1' })`
Mode.list	`return await $.Mode.list({ limit: 20 })`

Monitor

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

Motion

Operation	do program
Motion.get	`return await $.Motion.get({ id: 'motion_1' })`
Motion.list	`return await $.Motion.list({ limit: 20 })`

Noun

Operation	do program
Noun.create	`return await $.Noun.create({ name: 'Acme' })`
Noun.get	`return await $.Noun.get({ id: 'noun_1' })`
Noun.list	`return await $.Noun.list({ limit: 20 })`
Noun.update	`return await $.Noun.update({ id: 'noun_1', name: 'Acme' })`
Noun.delete	`return await $.Noun.delete({ id: 'noun_1' })`
Noun.retire	`return await $.Noun.retire({ noun: 'noun_1' })`
Noun.trace	`return await $.Noun.trace({ noun: 'noun_1' })`

Offer

Operation	do program
Offer.create	`return await $.Offer.create({ price: { amount: 49, currency: 'USD' } })`
Offer.get	`return await $.Offer.get({ id: 'offer_1' })`
Offer.list	`return await $.Offer.list({ limit: 20 })`
Offer.update	`return await $.Offer.update({ id: 'offer_1', price: { amount: 49, currency: 'USD' } })`
Offer.delete	`return await $.Offer.delete({ id: 'offer_1' })`
Offer.accept	`return await $.Offer.accept({ offer: 'offer_1', party: 'Ada Lovelace' })`
Offer.grant	`return await $.Offer.grant({ offer: 'offer_1', verb: 'verb_1' })`
Offer.publish	`return await $.Offer.publish({ offer: 'offer_1' })`
Offer.subscribe	`return await $.Offer.subscribe({ offer: 'offer_1' })`
Offer.trial	`return await $.Offer.trial({ offer: 'offer_1', customer: 'customer_1', days: 1 })`
Offer.withdraw	`return await $.Offer.withdraw({ offer: 'offer_1' })`

Opening

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

Order

Operation	do program
Order.create	`return await $.Order.create({ total: { amount: 49, currency: 'USD' } })`
Order.get	`return await $.Order.get({ id: 'order_1' })`
Order.list	`return await $.Order.list({ limit: 20 })`
Order.update	`return await $.Order.update({ id: 'order_1', total: { amount: 49, currency: 'USD' } })`
Order.cancel	`return await $.Order.cancel({ order: 'order_1' })`
Order.confirm	`return await $.Order.confirm({ order: 'order_1' })`
Order.deliver	`return await $.Order.deliver({ order: 'order_1', work: {} })`
Order.dispute	`return await $.Order.dispute({ order: 'order_1', reason: 'Example reason' })`
Order.fulfill	`return await $.Order.fulfill({ order: 'order_1' })`
Order.pay	`return await $.Order.pay({ order: 'order_1' })`
Order.place	`return await $.Order.place({ offer: 'offer_1' })`
Order.refund	`return await $.Order.refund({ order: 'order_1', reason: 'Example reason' })`
Order.revise	`return await $.Order.revise({ order: 'order_1', changes: 'Example changes' })`
Order.screen	`return await $.Order.screen({ order: 'order_1' })`
Order.start	`return await $.Order.start({ order: 'order_1', received: {} })`

Organization

Operation	do program
Organization.create	`return await $.Organization.create({ name: 'Acme' })`
Organization.get	`return await $.Organization.get({ id: 'organization_1' })`
Organization.list	`return await $.Organization.list({ limit: 20 })`
Organization.update	`return await $.Organization.update({ id: 'organization_1', name: 'Acme' })`
Organization.delete	`return await $.Organization.delete({ id: 'organization_1' })`
Organization.merge	`return await $.Organization.merge({ organization: 'organization_1', into: 'organization_1' })`

Outcome Contract

Operation	do program
OutcomeContract.get	`return await $.OutcomeContract.get({ id: 'outcome_contract_1' })`
OutcomeContract.list	`return await $.OutcomeContract.list({ limit: 20 })`
OutcomeContract.update	`return await $.OutcomeContract.update({ id: 'outcome_contract_1', done: 'Order.accepted' })`

Page

Operation	do program
Page.create	`return await $.Page.create({ path: '/' })`
Page.get	`return await $.Page.get({ id: 'page_1' })`
Page.list	`return await $.Page.list({ limit: 20 })`
Page.update	`return await $.Page.update({ id: 'page_1', path: '/' })`
Page.delete	`return await $.Page.delete({ id: 'page_1' })`

Partner

Operation	do program
Partner.create	`return await $.Partner.create({ name: 'Acme', side: 'supply' })`
Partner.get	`return await $.Partner.get({ id: 'partner_1' })`
Partner.list	`return await $.Partner.list({ limit: 20 })`
Partner.update	`return await $.Partner.update({ id: 'partner_1', side: 'supply' })`
Partner.delete	`return await $.Partner.delete({ id: 'partner_1' })`

Party

Operation	do program
Party.create	`return await $.Party.create({ name: 'Acme' })`
Party.get	`return await $.Party.get({ id: 'party_1' })`
Party.list	`return await $.Party.list({ limit: 20 })`
Party.update	`return await $.Party.update({ id: 'party_1', name: 'Acme' })`
Party.delete	`return await $.Party.delete({ id: 'party_1' })`
Party.screen	`return await $.Party.screen({ party: 'party_1' })`

Pay Run

Operation	do program
PayRun.get	`return await $.PayRun.get({ id: 'pay_run_1' })`
PayRun.list	`return await $.PayRun.list({ limit: 20 })`
PayRun.approve	`return await $.PayRun.approve({ payRun: 'pay_run_1' })`
PayRun.pay	`return await $.PayRun.pay({ payRun: 'pay_run_1' })`
PayRun.prepare	`return await $.PayRun.prepare({ company: 'company_1', periodStart: '2026-10-22', periodEnd: '2026-10-22', payDate: '2026-10-22' })`
PayRun.void	`return await $.PayRun.void({ payRun: 'pay_run_1', reason: 'Example reason' })`

Payment Source

Operation	do program
PaymentSource.get	`return await $.PaymentSource.get({ id: 'payment_source_1' })`
PaymentSource.list	`return await $.PaymentSource.list({ limit: 20 })`
PaymentSource.update	`return await $.PaymentSource.update({ id: 'payment_source_1', kind: 'card' })`
PaymentSource.add	`return await $.PaymentSource.add({ customer: 'customer_1', kind: 'card' })`
PaymentSource.remove	`return await $.PaymentSource.remove({ paymentSource: 'payment_source_1' })`

Period

Operation	do program
Period.get	`return await $.Period.get({ id: 'period_1' })`
Period.list	`return await $.Period.list({ limit: 20 })`
Period.update	`return await $.Period.update({ id: 'period_1', month: '2026-10-22' })`
Period.close	`return await $.Period.close({ period: 'period_1' })`
Period.lock	`return await $.Period.lock({ period: 'period_1' })`
Period.recognize	`return await $.Period.recognize({ period: 'period_1' })`

Permission

Operation	do program
Permission.create	`return await $.Permission.create({ scope: 'Example scope' })`
Permission.get	`return await $.Permission.get({ id: 'permission_1' })`
Permission.list	`return await $.Permission.list({ limit: 20 })`
Permission.update	`return await $.Permission.update({ id: 'permission_1', limit: 'limit_1' })`
Permission.delete	`return await $.Permission.delete({ id: 'permission_1' })`

Person

Operation	do program
Person.create	`return await $.Person.create({ name: 'Acme' })`
Person.get	`return await $.Person.get({ id: 'person_1' })`
Person.list	`return await $.Person.list({ limit: 20 })`
Person.update	`return await $.Person.update({ id: 'person_1', verified: true })`
Person.delete	`return await $.Person.delete({ id: 'person_1' })`

Persona

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

Play

Operation	do program
Play.create	`return await $.Play.create({ family: 'demand' })`
Play.get	`return await $.Play.get({ id: 'play_1' })`
Play.list	`return await $.Play.list({ limit: 20 })`
Play.update	`return await $.Play.update({ id: 'play_1', family: 'demand' })`
Play.delete	`return await $.Play.delete({ id: 'play_1' })`
Play.apply	`return await $.Play.apply({ play: 'play_1', cohort: 'Example cohort' })`

Play Mix

Operation	do program
PlayMix.get	`return await $.PlayMix.get({ id: 'play_mix_1' })`
PlayMix.list	`return await $.PlayMix.list({ limit: 20 })`
PlayMix.compile	`return await $.PlayMix.compile({ startup: 'startup_1' })`

Policy

Operation	do program
Policy.create	`return await $.Policy.create({ rule: 'Example rule' })`
Policy.get	`return await $.Policy.get({ id: 'policy_1' })`
Policy.list	`return await $.Policy.list({ limit: 20 })`
Policy.update	`return await $.Policy.update({ id: 'policy_1', rule: 'Example rule' })`
Policy.delete	`return await $.Policy.delete({ id: 'policy_1' })`

Portal

Operation	do program
Portal.create	`return await $.Portal.create({ path: '/' })`
Portal.get	`return await $.Portal.get({ id: 'portal_1' })`
Portal.list	`return await $.Portal.list({ limit: 20 })`
Portal.update	`return await $.Portal.update({ id: 'portal_1', path: '/' })`
Portal.delete	`return await $.Portal.delete({ id: 'portal_1' })`

Portfolio

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

Post

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

Problem

Operation	do program
Problem.create	`return await $.Problem.create({ statement: 'Drafts patents for solo inventors.' })`
Problem.get	`return await $.Problem.get({ id: 'problem_1' })`
Problem.list	`return await $.Problem.list({ limit: 20 })`
Problem.update	`return await $.Problem.update({ id: 'problem_1', statement: 'Drafts patents for solo inventors.' })`
Problem.delete	`return await $.Problem.delete({ id: 'problem_1' })`
Problem.rank	`return await $.Problem.rank({ icp: 'icp_1' })`
Problem.suggest	`return await $.Problem.suggest({ text: 'Example text' })`

Process

Operation	do program
Process.create	`return await $.Process.create({ name: 'Acme' })`
Process.get	`return await $.Process.get({ id: 'process_1' })`
Process.list	`return await $.Process.list({ limit: 20 })`
Process.update	`return await $.Process.update({ id: 'process_1', name: 'Acme' })`
Process.delete	`return await $.Process.delete({ id: 'process_1' })`
Process.enable	`return await $.Process.enable({ process: 'process_1' })`
Process.pause	`return await $.Process.pause({ process: 'process_1' })`

Product

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

Product Template

Operation	do program
ProductTemplate.create	`return await $.ProductTemplate.create({ slug: 'acme', kind: 'data', supply: 'Example supply', worker: 'agents', buyer: 'human', earningModel: 'subscription' })`
ProductTemplate.get	`return await $.ProductTemplate.get({ id: 'product_template_1' })`
ProductTemplate.list	`return await $.ProductTemplate.list({ limit: 20 })`
ProductTemplate.update	`return await $.ProductTemplate.update({ id: 'product_template_1', slug: 'acme' })`
ProductTemplate.delete	`return await $.ProductTemplate.delete({ id: 'product_template_1' })`

Project

Operation	do program
Project.create	`return await $.Project.create({ startsOn: '2026-10-22' })`
Project.get	`return await $.Project.get({ id: 'project_1' })`
Project.list	`return await $.Project.list({ limit: 20 })`
Project.update	`return await $.Project.update({ id: 'project_1', startsOn: '2026-10-22' })`
Project.delete	`return await $.Project.delete({ id: 'project_1' })`

Proof

Operation	do program
Proof.get	`return await $.Proof.get({ id: 'proof_1' })`
Proof.list	`return await $.Proof.list({ limit: 20 })`

Prospect

Operation	do program
Prospect.create	`return await $.Prospect.create({ foundIn: 'Example found in', basis: 'Example basis' })`
Prospect.get	`return await $.Prospect.get({ id: 'prospect_1' })`
Prospect.list	`return await $.Prospect.list({ limit: 20 })`
Prospect.update	`return await $.Prospect.update({ id: 'prospect_1', foundIn: 'Example found in' })`
Prospect.delete	`return await $.Prospect.delete({ id: 'prospect_1' })`
Prospect.engage	`return await $.Prospect.engage({ prospect: 'prospect_1' })`

Publication

Operation	do program
Publication.get	`return await $.Publication.get({ id: 'publication_1' })`
Publication.list	`return await $.Publication.list({ limit: 20 })`

Purpose

Operation	do program
Purpose.create	`return await $.Purpose.create({ name: 'Acme' })`
Purpose.get	`return await $.Purpose.get({ id: 'purpose_1' })`
Purpose.list	`return await $.Purpose.list({ limit: 20 })`
Purpose.update	`return await $.Purpose.update({ id: 'purpose_1', name: 'Acme' })`
Purpose.delete	`return await $.Purpose.delete({ id: 'purpose_1' })`

Question

Operation	do program
Question.get	`return await $.Question.get({ id: 'question_1' })`
Question.list	`return await $.Question.list({ limit: 20 })`

Quote

Operation	do program
Quote.create	`return await $.Quote.create({ total: { amount: 49, currency: 'USD' }, validUntil: '2026-10-22', lines: {} })`
Quote.get	`return await $.Quote.get({ id: 'quote_1' })`
Quote.list	`return await $.Quote.list({ limit: 20 })`
Quote.update	`return await $.Quote.update({ id: 'quote_1', total: { amount: 49, currency: 'USD' } })`
Quote.delete	`return await $.Quote.delete({ id: 'quote_1' })`
Quote.accept	`return await $.Quote.accept({ quote: 'quote_1', party: 'party_1' })`
Quote.decline	`return await $.Quote.decline({ quote: 'quote_1' })`
Quote.expire	`return await $.Quote.expire({ quote: 'quote_1' })`
Quote.request	`return await $.Quote.request({ offers: ['offer_1'] })`
Quote.send	`return await $.Quote.send({ quote: 'quote_1' })`
Quote.supersede	`return await $.Quote.supersede({ quote: 'quote_1', by: 'quote_1' })`

Readout

Operation	do program
Readout.create	`return await $.Readout.create({ value: 1, n: 1, readability: 'A' })`
Readout.get	`return await $.Readout.get({ id: 'readout_1' })`
Readout.list	`return await $.Readout.list({ limit: 20 })`
Readout.update	`return await $.Readout.update({ id: 'readout_1', value: 1 })`
Readout.delete	`return await $.Readout.delete({ id: 'readout_1' })`

Recording

Operation	do program
Recording.get	`return await $.Recording.get({ id: 'recording_1' })`
Recording.list	`return await $.Recording.list({ limit: 20 })`

Recovery Objective

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

Referral

Operation	do program
Referral.create	`return await $.Referral.create({ reward: { amount: 49, currency: 'USD' } })`
Referral.get	`return await $.Referral.get({ id: 'referral_1' })`
Referral.list	`return await $.Referral.list({ limit: 20 })`
Referral.update	`return await $.Referral.update({ id: 'referral_1', reward: { amount: 49, currency: 'USD' } })`
Referral.delete	`return await $.Referral.delete({ id: 'referral_1' })`

Registration

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

Relationship

Operation	do program
Relationship.create	`return await $.Relationship.create({ predicate: 'Example predicate', inverse: 'Example inverse' })`
Relationship.get	`return await $.Relationship.get({ id: 'relationship_1' })`
Relationship.list	`return await $.Relationship.list({ limit: 20 })`
Relationship.update	`return await $.Relationship.update({ id: 'relationship_1', provenance: 'Stated' })`
Relationship.delete	`return await $.Relationship.delete({ id: 'relationship_1' })`

Renewal

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

Reserved Act

Operation	do program
ReservedAct.create	`return await $.ReservedAct.create({ jurisdiction: 'US-DE' })`
ReservedAct.get	`return await $.ReservedAct.get({ id: 'reserved_act_1' })`
ReservedAct.list	`return await $.ReservedAct.list({ limit: 20 })`
ReservedAct.update	`return await $.ReservedAct.update({ id: 'reserved_act_1', jurisdiction: 'US-DE' })`
ReservedAct.delete	`return await $.ReservedAct.delete({ id: 'reserved_act_1' })`

Review

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

Risk

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

Role

Operation	do program
Role.create	`return await $.Role.create({ name: 'Acme' })`
Role.get	`return await $.Role.get({ id: 'role_1' })`
Role.list	`return await $.Role.list({ limit: 20 })`
Role.update	`return await $.Role.update({ id: 'role_1', name: 'Acme' })`
Role.delete	`return await $.Role.delete({ id: 'role_1' })`
Role.review	`return await $.Role.review({ role: 'role_1', period: 'Example period' })`
Role.staff	`return await $.Role.staff({ role: 'role_1', worker: 'worker_1' })`
Role.vacate	`return await $.Role.vacate({ role: 'role_1' })`

Role Review

Operation	do program
RoleReview.get	`return await $.RoleReview.get({ id: 'role_review_1' })`
RoleReview.list	`return await $.RoleReview.list({ limit: 20 })`

Screening

Operation	do program
Screening.get	`return await $.Screening.get({ id: 'screening_1' })`
Screening.list	`return await $.Screening.list({ limit: 20 })`

Secret

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

Sequence

Operation	do program
Sequence.create	`return await $.Sequence.create({ steps: {} })`
Sequence.get	`return await $.Sequence.get({ id: 'sequence_1' })`
Sequence.list	`return await $.Sequence.list({ limit: 20 })`
Sequence.update	`return await $.Sequence.update({ id: 'sequence_1', steps: {} })`
Sequence.delete	`return await $.Sequence.delete({ id: 'sequence_1' })`

Service

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

Setting

Operation	do program
Setting.create	`return await $.Setting.create({ key: 'Example key', value: {} })`
Setting.get	`return await $.Setting.get({ id: 'setting_1' })`
Setting.list	`return await $.Setting.list({ limit: 20 })`
Setting.update	`return await $.Setting.update({ id: 'setting_1', value: {} })`
Setting.delete	`return await $.Setting.delete({ id: 'setting_1' })`

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

Site

Operation	do program
Site.create	`return await $.Site.create({ kind: 'api' })`
Site.get	`return await $.Site.get({ id: 'site_1' })`
Site.list	`return await $.Site.list({ limit: 20 })`
Site.update	`return await $.Site.update({ id: 'site_1', navigation: {} })`
Site.delete	`return await $.Site.delete({ id: 'site_1' })`
Site.publish	`return await $.Site.publish({ site: 'site_1' })`

Skill

Operation	do program
Skill.create	`return await $.Skill.create({ level: 1 })`
Skill.get	`return await $.Skill.get({ id: 'skill_1' })`
Skill.list	`return await $.Skill.list({ limit: 20 })`
Skill.update	`return await $.Skill.update({ id: 'skill_1', level: 1 })`
Skill.delete	`return await $.Skill.delete({ id: 'skill_1' })`

Software

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

Source

Operation	do program
Source.create	`return await $.Source.create({ acquired: 'owned' })`
Source.get	`return await $.Source.get({ id: 'source_1' })`
Source.list	`return await $.Source.list({ limit: 20 })`
Source.update	`return await $.Source.update({ id: 'source_1', acquired: 'owned' })`
Source.delete	`return await $.Source.delete({ id: 'source_1' })`

SSO Connection

Operation	do program
SSOConnection.create	`return await $.SSOConnection.create({ protocol: 'saml' })`
SSOConnection.get	`return await $.SSOConnection.get({ id: 'sso_connection_1' })`
SSOConnection.list	`return await $.SSOConnection.list({ limit: 20 })`
SSOConnection.update	`return await $.SSOConnection.update({ id: 'sso_connection_1', protocol: 'saml' })`
SSOConnection.activate	`return await $.SSOConnection.activate({ connection: 'sso_connection_1' })`
SSOConnection.deactivate	`return await $.SSOConnection.deactivate({ connection: 'sso_connection_1' })`

Standard

Operation	do program
Standard.get	`return await $.Standard.get({ id: 'standard_1' })`
Standard.list	`return await $.Standard.list({ limit: 20 })`

Startup

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

Startup Template

Operation	do program
StartupTemplate.create	`return await $.StartupTemplate.create({ slug: 'acme', operatingModel: 'autonomous', motions: ['Example motions'] })`
StartupTemplate.get	`return await $.StartupTemplate.get({ id: 'startup_template_1' })`
StartupTemplate.list	`return await $.StartupTemplate.list({ limit: 20 })`
StartupTemplate.update	`return await $.StartupTemplate.update({ id: 'startup_template_1', slug: 'acme' })`
StartupTemplate.delete	`return await $.StartupTemplate.delete({ id: 'startup_template_1' })`
StartupTemplate.extend	`return await $.StartupTemplate.extend({ startupTemplate: 'startup_template_1', startup: 'startup_1' })`
StartupTemplate.promote	`return await $.StartupTemplate.promote({ startupTemplate: 'startup_template_1', startup: 'startup_1' })`
StartupTemplate.upgrade	`return await $.StartupTemplate.upgrade({ startupTemplate: 'startup_template_1', startup: 'startup_1' })`

Statement

Operation	do program
Statement.get	`return await $.Statement.get({ id: 'statement_1' })`
Statement.list	`return await $.Statement.list({ limit: 20 })`

Story

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

Studio

Operation	do program
Studio.create	`return await $.Studio.create({ name: 'Acme' })`
Studio.get	`return await $.Studio.get({ id: 'studio_1' })`
Studio.list	`return await $.Studio.list({ limit: 20 })`
Studio.update	`return await $.Studio.update({ id: 'studio_1', name: 'Acme' })`
Studio.delete	`return await $.Studio.delete({ id: 'studio_1' })`

Subscription

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

Supplier

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

Suppression

Operation	do program
Suppression.create	`return await $.Suppression.create({ address: 'Example address' })`
Suppression.get	`return await $.Suppression.get({ id: 'suppression_1' })`
Suppression.list	`return await $.Suppression.list({ limit: 20 })`

Survey

Operation	do program
Survey.create	`return await $.Survey.create({ fields: {} })`
Survey.get	`return await $.Survey.get({ id: 'survey_1' })`
Survey.list	`return await $.Survey.list({ limit: 20 })`
Survey.update	`return await $.Survey.update({ id: 'survey_1', fields: {} })`
Survey.delete	`return await $.Survey.delete({ id: 'survey_1' })`

System

Operation	do program
System.create	`return await $.System.create({ job: 'Example job' })`
System.get	`return await $.System.get({ id: 'system_1' })`
System.list	`return await $.System.list({ limit: 20 })`
System.update	`return await $.System.update({ id: 'system_1', job: 'Example job' })`
System.delete	`return await $.System.delete({ id: 'system_1' })`

Task

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

Team

Operation	do program
Team.create	`return await $.Team.create({ mission: 'Example mission' })`
Team.get	`return await $.Team.get({ id: 'team_1' })`
Team.list	`return await $.Team.list({ limit: 20 })`
Team.update	`return await $.Team.update({ id: 'team_1', mission: 'Example mission' })`
Team.delete	`return await $.Team.delete({ id: 'team_1' })`

Template

Operation	do program
Template.create	`return await $.Template.create({ body: 'Example body' })`
Template.get	`return await $.Template.get({ id: 'template_1' })`
Template.list	`return await $.Template.list({ limit: 20 })`
Template.update	`return await $.Template.update({ id: 'template_1', body: 'Example body' })`
Template.delete	`return await $.Template.delete({ id: 'template_1' })`
Template.extend	`return await $.Template.extend({ template: 'template_1', startup: 'startup_1' })`
Template.promote	`return await $.Template.promote({ template: 'template_1', startup: 'startup_1' })`
Template.upgrade	`return await $.Template.upgrade({ template: 'template_1', startup: 'startup_1' })`

Tenant

Operation	do program
Tenant.create	`return await $.Tenant.create({ placement: 'path' })`
Tenant.get	`return await $.Tenant.get({ id: 'tenant_1' })`
Tenant.list	`return await $.Tenant.list({ limit: 20 })`
Tenant.update	`return await $.Tenant.update({ id: 'tenant_1', placement: 'path' })`
Tenant.delete	`return await $.Tenant.delete({ id: 'tenant_1' })`
Tenant.invite	`return await $.Tenant.invite({ tenant: 'tenant_1', email: 'ada@acme.com' })`
Tenant.pin	`return await $.Tenant.pin({ tenant: 'tenant_1', apiVersion: 'v2' })`
Tenant.provision	`return await $.Tenant.provision({ customer: 'customer_1' })`
Tenant.requestSetup	`return await $.Tenant.requestSetup({ tenant: 'tenant_1', admin: 'person_1', intent: 'sso' })`

Theme

Operation	do program
Theme.create	`return await $.Theme.create({ tokens: {} })`
Theme.get	`return await $.Theme.get({ id: 'theme_1' })`
Theme.list	`return await $.Theme.list({ limit: 20 })`
Theme.update	`return await $.Theme.update({ id: 'theme_1', tokens: {} })`
Theme.delete	`return await $.Theme.delete({ id: 'theme_1' })`

Thing

Operation	do program
Thing.create	`return await $.Thing.create({ id: 'thing_1', type: ['noun_1'] })`
Thing.get	`return await $.Thing.get({ id: 'thing_1' })`
Thing.list	`return await $.Thing.list({ limit: 20 })`
Thing.update	`return await $.Thing.update({ id: 'thing_1', type: ['noun_1'] })`
Thing.delete	`return await $.Thing.delete({ id: 'thing_1' })`
Thing.relate	`return await $.Thing.relate({ thing: 'thing_1', predicate: 'Example predicate', to: 'thing_1' })`
Thing.resolve	`return await $.Thing.resolve({ noun: 'noun_1', match: {} })`
Thing.share	`return await $.Thing.share({ thing: 'thing_1', to: 'party_1', verbs: ['Example verbs'] })`
Thing.unrelate	`return await $.Thing.unrelate({ thing: 'thing_1', predicate: 'Example predicate', to: 'thing_1' })`

Thread

Operation	do program
Thread.create	`return await $.Thread.create({ subject: 'Example subject' })`
Thread.get	`return await $.Thread.get({ id: 'thread_1' })`
Thread.list	`return await $.Thread.list({ limit: 20 })`
Thread.update	`return await $.Thread.update({ id: 'thread_1', subject: 'Example subject' })`
Thread.delete	`return await $.Thread.delete({ id: 'thread_1' })`

Tool

Operation	do program
Tool.create	`return await $.Tool.create({ name: 'Acme' })`
Tool.get	`return await $.Tool.get({ id: 'tool_1' })`
Tool.list	`return await $.Tool.list({ limit: 20 })`
Tool.update	`return await $.Tool.update({ id: 'tool_1', name: 'Acme' })`
Tool.delete	`return await $.Tool.delete({ id: 'tool_1' })`

Transaction

Operation	do program
Transaction.get	`return await $.Transaction.get({ id: 'transaction_1' })`
Transaction.list	`return await $.Transaction.list({ limit: 20 })`
Transaction.attach	`return await $.Transaction.attach({ transaction: 'transaction_1' })`
Transaction.categorize	`return await $.Transaction.categorize({ transaction: 'transaction_1' })`
Transaction.reconcile	`return await $.Transaction.reconcile({ transaction: 'transaction_1' })`

Trigger

Operation	do program
Trigger.create	`return await $.Trigger.create({ event: 'Example event' })`
Trigger.get	`return await $.Trigger.get({ id: 'trigger_1' })`
Trigger.list	`return await $.Trigger.list({ limit: 20 })`
Trigger.update	`return await $.Trigger.update({ id: 'trigger_1', threshold: {} })`
Trigger.delete	`return await $.Trigger.delete({ id: 'trigger_1' })`

Variant

Operation	do program
Variant.create	`return await $.Variant.create({ key: 'Example key', value: {} })`
Variant.get	`return await $.Variant.get({ id: 'variant_1' })`
Variant.list	`return await $.Variant.list({ limit: 20 })`
Variant.update	`return await $.Variant.update({ id: 'variant_1', value: {} })`
Variant.delete	`return await $.Variant.delete({ id: 'variant_1' })`

Verb

Operation	do program
Verb.create	`return await $.Verb.create({ name: 'Acme', event: 'Example event' })`
Verb.get	`return await $.Verb.get({ id: 'verb_1' })`
Verb.list	`return await $.Verb.list({ limit: 20 })`
Verb.update	`return await $.Verb.update({ id: 'verb_1', name: 'Acme' })`
Verb.delete	`return await $.Verb.delete({ id: 'verb_1' })`
Verb.retire	`return await $.Verb.retire({ verb: 'verb_1' })`

Version

Operation	do program
Version.get	`return await $.Version.get({ id: 'version_1' })`
Version.list	`return await $.Version.list({ limit: 20 })`
Version.deploy	`return await $.Version.deploy({ version: 'version_1' })`

Video

Operation	do program
Video.create	`return await $.Video.create({ timeline: {}, brand: 'brand_1' })`
Video.get	`return await $.Video.get({ id: 'video_1' })`
Video.list	`return await $.Video.list({ limit: 20 })`
Video.update	`return await $.Video.update({ id: 'video_1', timeline: {} })`
Video.draft	`return await $.Video.draft({ brand: 'brand_1' })`
Video.finalize	`return await $.Video.finalize({ video: 'video_1' })`

Visit

Operation	do program
Visit.get	`return await $.Visit.get({ id: 'visit_1' })`
Visit.list	`return await $.Visit.list({ limit: 20 })`

Visitor

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

Voice

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

Waitlist

Operation	do program
Waitlist.create	`return await $.Waitlist.create({ invited: 1 })`
Waitlist.get	`return await $.Waitlist.get({ id: 'waitlist_1' })`
Waitlist.list	`return await $.Waitlist.list({ limit: 20 })`
Waitlist.update	`return await $.Waitlist.update({ id: 'waitlist_1', invited: 1 })`
Waitlist.delete	`return await $.Waitlist.delete({ id: 'waitlist_1' })`
Waitlist.admit	`return await $.Waitlist.admit({ waitlist: 'waitlist_1', count: 1 })`
Waitlist.join	`return await $.Waitlist.join({ waitlist: 'waitlist_1', email: 'ada@acme.com' })`

Watch

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

Worker

Operation	do program
Worker.create	`return await $.Worker.create({ name: 'Acme' })`
Worker.get	`return await $.Worker.get({ id: 'worker_1' })`
Worker.list	`return await $.Worker.list({ limit: 20 })`
Worker.update	`return await $.Worker.update({ id: 'worker_1', name: 'Acme' })`
Worker.delete	`return await $.Worker.delete({ id: 'worker_1' })`

Workflow

Operation	do program
Workflow.create	`return await $.Workflow.create({ steps: {} })`
Workflow.get	`return await $.Workflow.get({ id: 'workflow_1' })`
Workflow.list	`return await $.Workflow.list({ limit: 20 })`
Workflow.update	`return await $.Workflow.update({ id: 'workflow_1', steps: {} })`
Workflow.delete	`return await $.Workflow.delete({ id: 'workflow_1' })`

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