API routes · StartupBuilder

Every Verb on every Noun as an api.sb route, with the Event it emits.

Grammar

Text

POST   /{namespace}/{nouns}                create
GET    /{namespace}/{nouns}                list
GET    /{namespace}/{nouns}/{id}           get
PATCH  /{namespace}/{nouns}/{id}           update
DELETE /{namespace}/{nouns}/{id}           delete
POST   /{namespace}/{nouns}/{id}/{verb}    a Verb on one record
POST   /{namespace}/{nouns}/{verb}         a Verb on the collection

The API spec covers authentication, Modes, and errors.

Access Level

Operation	Route	Event
AccessLevel.get	`GET /{namespace}/access-levels/{id}`	None.
AccessLevel.list	`GET /{namespace}/access-levels`	None.

Account

Operation	Route	Event
Account.get	`GET /{namespace}/accounts/{id}`	None.
Account.list	`GET /{namespace}/accounts`	None.
Account.payout	`POST /{namespace}/accounts/{account}/payout`	`Account.paidOut`
Account.sweep	`POST /{namespace}/accounts/{from}/sweep`	`Account.swept`

Acquisition

Operation	Route	Event
Acquisition.get	`GET /{namespace}/acquisitions/{id}`	None.
Acquisition.list	`GET /{namespace}/acquisitions`	None.

Action

Operation	Route	Event
Action.create	`POST /{namespace}/actions`	`Action.created`
Action.get	`GET /{namespace}/actions/{id}`	None.
Action.list	`GET /{namespace}/actions`	None.
Action.answer	`POST /{namespace}/actions/{action}/answer`	`Action.answered`
Action.ask	`POST /{namespace}/actions/{action}/ask`	`Action.asked`
Action.attest	`POST /{namespace}/actions/{action}/attest`	`Action.attested`
Action.cancel	`POST /{namespace}/actions/{action}/cancel`	`Action.canceled`
Action.evaluate	`POST /{namespace}/actions/{action}/evaluate`	`Action.evaluated`
Action.pause	`POST /{namespace}/actions/{action}/pause`	`Action.paused`
Action.redirect	`POST /{namespace}/actions/{action}/redirect`	`Action.redirected`
Action.resume	`POST /{namespace}/actions/{action}/resume`	`Action.resumed`
Action.retry	`POST /{namespace}/actions/{action}/retry`	`Action.retried`

Operation	Route	Event
Ad.create	`POST /{namespace}/ads`	`Ad.created`
Ad.get	`GET /{namespace}/ads/{id}`	None.
Ad.list	`GET /{namespace}/ads`	None.
Ad.update	`PATCH /{namespace}/ads/{id}`	`Ad.updated`
Ad.delete	`DELETE /{namespace}/ads/{id}`	`Ad.deleted`

Agent

Operation	Route	Event
Agent.create	`POST /{namespace}/agents`	`Agent.created`
Agent.get	`GET /{namespace}/agents/{id}`	None.
Agent.list	`GET /{namespace}/agents`	None.
Agent.update	`PATCH /{namespace}/agents/{id}`	`Agent.updated`
Agent.delete	`DELETE /{namespace}/agents/{id}`	`Agent.deleted`
Agent.mint	`POST /{namespace}/agents/mint`	`Agent.minted`
Agent.pause	`POST /{namespace}/agents/pause`	`Agent.paused`
Agent.resume	`POST /{namespace}/agents/{agent}/resume`	`Agent.resumed`
Agent.retire	`POST /{namespace}/agents/{agent}/retire`	`Agent.retired`

Agreement

Operation	Route	Event
Agreement.create	`POST /{namespace}/agreements`	`Agreement.created`
Agreement.get	`GET /{namespace}/agreements/{id}`	None.
Agreement.list	`GET /{namespace}/agreements`	None.
Agreement.update	`PATCH /{namespace}/agreements/{id}`	`Agreement.updated`
Agreement.sign	`POST /{namespace}/agreements/{agreement}/sign`	`Agreement.signed`
Agreement.terminate	`POST /{namespace}/agreements/{agreement}/terminate`	`Agreement.terminated`

API Key

Operation	Route	Event
APIKey.get	`GET /{namespace}/api-keys/{id}`	None.
APIKey.list	`GET /{namespace}/api-keys`	None.
APIKey.issue	`POST /{namespace}/api-keys/issue`	`APIKey.issued`
APIKey.revoke	`POST /{namespace}/api-keys/{apiKey}/revoke`	`APIKey.revoked`
APIKey.roll	`POST /{namespace}/api-keys/{apiKey}/roll`	`APIKey.rolled`

App

Operation	Route	Event
App.publish	`POST /{namespace}/apps/{app}/publish`	`App.published`

Approval

Operation	Route	Event
Approval.create	`POST /{namespace}/approvals`	`Approval.created`
Approval.get	`GET /{namespace}/approvals/{id}`	None.
Approval.list	`GET /{namespace}/approvals`	None.
Approval.update	`PATCH /{namespace}/approvals/{id}`	`Approval.updated`
Approval.delete	`DELETE /{namespace}/approvals/{id}`	`Approval.deleted`
Approval.approve	`POST /{namespace}/approvals/{approval}/approve`	`Approval.approved`
Approval.refuse	`POST /{namespace}/approvals/{approval}/refuse`	`Approval.refused`

Attestation

Operation	Route	Event
Attestation.create	`POST /{namespace}/attestations`	`Attestation.created`
Attestation.get	`GET /{namespace}/attestations/{id}`	None.
Attestation.list	`GET /{namespace}/attestations`	None.

Audience

Operation	Route	Event
Audience.create	`POST /{namespace}/audiences`	`Audience.created`
Audience.get	`GET /{namespace}/audiences/{id}`	None.
Audience.list	`GET /{namespace}/audiences`	None.
Audience.update	`PATCH /{namespace}/audiences/{id}`	`Audience.updated`
Audience.delete	`DELETE /{namespace}/audiences/{id}`	`Audience.deleted`

Audit

Operation	Route	Event
Audit.get	`GET /{namespace}/audits/{id}`	None.
Audit.list	`GET /{namespace}/audits`	None.

Bill

Operation	Route	Event
Bill.create	`POST /{namespace}/bills`	`Bill.created`
Bill.get	`GET /{namespace}/bills/{id}`	None.
Bill.list	`GET /{namespace}/bills`	None.
Bill.update	`PATCH /{namespace}/bills/{id}`	`Bill.updated`
Bill.approve	`POST /{namespace}/bills/{bill}/approve`	`Bill.approved`
Bill.pay	`POST /{namespace}/bills/{bill}/pay`	`Bill.paid`

Brand

Operation	Route	Event
Brand.create	`POST /{namespace}/brands`	`Brand.created`
Brand.get	`GET /{namespace}/brands/{id}`	None.
Brand.list	`GET /{namespace}/brands`	None.
Brand.update	`PATCH /{namespace}/brands/{id}`	`Brand.updated`
Brand.delete	`DELETE /{namespace}/brands/{id}`	`Brand.deleted`
Brand.clear	`POST /{namespace}/brands/{brand}/clear`	`Brand.cleared`

Budget

Operation	Route	Event
Budget.create	`POST /{namespace}/budgets`	`Budget.created`
Budget.get	`GET /{namespace}/budgets/{id}`	None.
Budget.list	`GET /{namespace}/budgets`	None.
Budget.update	`PATCH /{namespace}/budgets/{id}`	`Budget.updated`
Budget.delete	`DELETE /{namespace}/budgets/{id}`	`Budget.deleted`

Builder

Operation	Route	Event
Builder.get	`GET /{namespace}/builders/{id}`	None.
Builder.list	`GET /{namespace}/builders`	None.

Campaign

Operation	Route	Event
Campaign.create	`POST /{namespace}/campaigns`	`Campaign.created`
Campaign.get	`GET /{namespace}/campaigns/{id}`	None.
Campaign.list	`GET /{namespace}/campaigns`	None.
Campaign.update	`PATCH /{namespace}/campaigns/{id}`	`Campaign.updated`
Campaign.delete	`DELETE /{namespace}/campaigns/{id}`	`Campaign.deleted`

Candidate

Operation	Route	Event
Candidate.create	`POST /{namespace}/candidates`	`Candidate.created`
Candidate.get	`GET /{namespace}/candidates/{id}`	None.
Candidate.list	`GET /{namespace}/candidates`	None.
Candidate.update	`PATCH /{namespace}/candidates/{id}`	`Candidate.updated`
Candidate.delete	`DELETE /{namespace}/candidates/{id}`	`Candidate.deleted`
Candidate.screen	`POST /{namespace}/candidates/{candidate}/screen`	`Candidate.screened`

Capability

Operation	Route	Event
Capability.get	`GET /{namespace}/capabilities/{id}`	None.
Capability.list	`GET /{namespace}/capabilities`	None.

Capital Call

Operation	Route	Event
CapitalCall.get	`GET /{namespace}/capital-calls/{id}`	None.
CapitalCall.list	`GET /{namespace}/capital-calls`	None.

Capital Commitment

Operation	Route	Event
CapitalCommitment.create	`POST /{namespace}/capital-commitments`	`CapitalCommitment.created`
CapitalCommitment.get	`GET /{namespace}/capital-commitments/{id}`	None.
CapitalCommitment.list	`GET /{namespace}/capital-commitments`	None.
CapitalCommitment.update	`PATCH /{namespace}/capital-commitments/{id}`	`CapitalCommitment.updated`
CapitalCommitment.countersign	`POST /{namespace}/capital-commitments/{commitment}/countersign`	`CapitalCommitment.countersigned`

Card

Operation	Route	Event
Card.get	`GET /{namespace}/cards/{id}`	None.
Card.list	`GET /{namespace}/cards`	None.
Card.issue	`POST /{namespace}/cards/issue`	`Card.issued`

Change

Operation	Route	Event
Change.create	`POST /{namespace}/changes`	`Change.created`
Change.get	`GET /{namespace}/changes/{id}`	None.
Change.list	`GET /{namespace}/changes`	None.
Change.merge	`POST /{namespace}/changes/{change}/merge`	`Change.merged`
Change.revert	`POST /{namespace}/changes/{change}/revert`	`Change.reverted`
Change.review	`POST /{namespace}/changes/{change}/review`	`Change.reviewed`

Channel

Operation	Route	Event
Channel.create	`POST /{namespace}/channels`	`Channel.created`
Channel.get	`GET /{namespace}/channels/{id}`	None.
Channel.list	`GET /{namespace}/channels`	None.
Channel.update	`PATCH /{namespace}/channels/{id}`	`Channel.updated`
Channel.delete	`DELETE /{namespace}/channels/{id}`	`Channel.deleted`

Cohort

Operation	Route	Event
Cohort.create	`POST /{namespace}/cohorts`	`Cohort.created`
Cohort.get	`GET /{namespace}/cohorts/{id}`	None.
Cohort.list	`GET /{namespace}/cohorts`	None.
Cohort.update	`PATCH /{namespace}/cohorts/{id}`	`Cohort.updated`
Cohort.delete	`DELETE /{namespace}/cohorts/{id}`	`Cohort.deleted`

Collection

Operation	Route	Event
Collection.create	`POST /{namespace}/collections`	`Collection.created`
Collection.get	`GET /{namespace}/collections/{id}`	None.
Collection.list	`GET /{namespace}/collections`	None.
Collection.update	`PATCH /{namespace}/collections/{id}`	`Collection.updated`
Collection.delete	`DELETE /{namespace}/collections/{id}`	`Collection.deleted`
Collection.export	`POST /{namespace}/collections/{collection}/export`	`Collection.exported`
Collection.query	`POST /{namespace}/collections/query`	`Collection.queried`

Comment

Operation	Route	Event
Comment.create	`POST /{namespace}/comments`	`Comment.created`
Comment.get	`GET /{namespace}/comments/{id}`	None.
Comment.list	`GET /{namespace}/comments`	None.
Comment.update	`PATCH /{namespace}/comments/{id}`	`Comment.updated`
Comment.delete	`DELETE /{namespace}/comments/{id}`	`Comment.deleted`

Commission

Operation	Route	Event
Commission.create	`POST /{namespace}/commissions`	`Commission.created`
Commission.get	`GET /{namespace}/commissions/{id}`	None.
Commission.list	`GET /{namespace}/commissions`	None.
Commission.update	`PATCH /{namespace}/commissions/{id}`	`Commission.updated`
Commission.pay	`POST /{namespace}/commissions/{commission}/pay`	`Commission.paid`

Company

Operation	Route	Event
Company.create	`POST /{namespace}/companies`	`Company.created`
Company.get	`GET /{namespace}/companies/{id}`	None.
Company.list	`GET /{namespace}/companies`	None.
Company.update	`PATCH /{namespace}/companies/{id}`	`Company.updated`
Company.dissolve	`POST /{namespace}/companies/{company}/dissolve`	`Company.dissolved`
Company.incorporate	`POST /{namespace}/companies/incorporate`	`Company.incorporated`
Company.register	`POST /{namespace}/companies/register`	`Company.registered`
Company.submit	`POST /{namespace}/companies/submit`	`Company.submitted`

Component

Operation	Route	Event
Component.create	`POST /{namespace}/components`	`Component.created`
Component.get	`GET /{namespace}/components/{id}`	None.
Component.list	`GET /{namespace}/components`	None.
Component.update	`PATCH /{namespace}/components/{id}`	`Component.updated`
Component.delete	`DELETE /{namespace}/components/{id}`	`Component.deleted`

Operation	Route	Event
Consent.create	`POST /{namespace}/consents`	`Consent.created`
Consent.get	`GET /{namespace}/consents/{id}`	None.
Consent.list	`GET /{namespace}/consents`	None.
Consent.update	`PATCH /{namespace}/consents/{id}`	`Consent.updated`
Consent.withdraw	`POST /{namespace}/consents/{consent}/withdraw`	`Consent.withdrawn`

Contact

Operation	Route	Event
Contact.create	`POST /{namespace}/contacts`	`Contact.created`
Contact.get	`GET /{namespace}/contacts/{id}`	None.
Contact.list	`GET /{namespace}/contacts`	None.
Contact.update	`PATCH /{namespace}/contacts/{id}`	`Contact.updated`
Contact.delete	`DELETE /{namespace}/contacts/{id}`	`Contact.deleted`
Contact.enrich	`POST /{namespace}/contacts/{contact}/enrich`	`Contact.enriched`
Contact.enroll	`POST /{namespace}/contacts/{contact}/enroll`	`Contact.enrolled`
Contact.merge	`POST /{namespace}/contacts/{contact}/merge`	`Contact.merged`
Contact.subscribe	`POST /{namespace}/contacts/{contact}/subscribe`	`Contact.subscribed`
Contact.suppress	`POST /{namespace}/contacts/{contact}/suppress`	`Contact.suppressed`
Contact.unsubscribe	`POST /{namespace}/contacts/{contact}/unsubscribe`	`Contact.unsubscribed`

Content

Operation	Route	Event
Content.create	`POST /{namespace}/content`	`Content.created`
Content.get	`GET /{namespace}/content/{id}`	None.
Content.list	`GET /{namespace}/content`	None.
Content.update	`PATCH /{namespace}/content/{id}`	`Content.updated`
Content.delete	`DELETE /{namespace}/content/{id}`	`Content.deleted`
Content.draft	`POST /{namespace}/content/draft`	`Content.drafted`
Content.publish	`POST /{namespace}/content/{content}/publish`	`Content.published`

Control

Operation	Route	Event
Control.get	`GET /{namespace}/controls/{id}`	None.
Control.list	`GET /{namespace}/controls`	None.

Conversation

Operation	Route	Event
Conversation.create	`POST /{namespace}/conversations`	`Conversation.created`
Conversation.get	`GET /{namespace}/conversations/{id}`	None.
Conversation.list	`GET /{namespace}/conversations`	None.
Conversation.update	`PATCH /{namespace}/conversations/{id}`	`Conversation.updated`
Conversation.delete	`DELETE /{namespace}/conversations/{id}`	`Conversation.deleted`
Conversation.answer	`POST /{namespace}/conversations/{conversation}/answer`	`Conversation.answered`
Conversation.assign	`POST /{namespace}/conversations/{conversation}/assign`	`Conversation.assigned`
Conversation.close	`POST /{namespace}/conversations/{conversation}/close`	`Conversation.closed`
Conversation.escalate	`POST /{namespace}/conversations/{conversation}/escalate`	`Conversation.escalated`
Conversation.reopen	`POST /{namespace}/conversations/{conversation}/reopen`	`Conversation.reopened`

Cost

Operation	Route	Event
Cost.get	`GET /{namespace}/costs/{id}`	None.
Cost.list	`GET /{namespace}/costs`	None.

Coupon

Operation	Route	Event
Coupon.create	`POST /{namespace}/coupons`	`Coupon.created`
Coupon.get	`GET /{namespace}/coupons/{id}`	None.
Coupon.list	`GET /{namespace}/coupons`	None.
Coupon.update	`PATCH /{namespace}/coupons/{id}`	`Coupon.updated`

Credential

Operation	Route	Event
Credential.create	`POST /{namespace}/credentials`	`Credential.created`
Credential.get	`GET /{namespace}/credentials/{id}`	None.
Credential.list	`GET /{namespace}/credentials`	None.
Credential.update	`PATCH /{namespace}/credentials/{id}`	`Credential.updated`
Credential.delete	`DELETE /{namespace}/credentials/{id}`	`Credential.deleted`
Credential.verify	`POST /{namespace}/credentials/{credential}/verify`	`Credential.verified`

Credit Grant

Operation	Route	Event
CreditGrant.create	`POST /{namespace}/credit-grants`	`CreditGrant.created`
CreditGrant.get	`GET /{namespace}/credit-grants/{id}`	None.
CreditGrant.list	`GET /{namespace}/credit-grants`	None.
CreditGrant.apply	`POST /{namespace}/credit-grants/apply`	`CreditGrant.applied`
CreditGrant.issue	`POST /{namespace}/credit-grants/issue`	`CreditGrant.issued`
CreditGrant.void	`POST /{namespace}/credit-grants/{creditGrant}/void`	`CreditGrant.voided`

Criterion

Operation	Route	Event
Criterion.get	`GET /{namespace}/criteria/{id}`	None.
Criterion.list	`GET /{namespace}/criteria`	None.

Customer

Operation	Route	Event
Customer.create	`POST /{namespace}/customers`	`Customer.created`
Customer.get	`GET /{namespace}/customers/{id}`	None.
Customer.list	`GET /{namespace}/customers`	None.
Customer.update	`PATCH /{namespace}/customers/{id}`	`Customer.updated`
Customer.delete	`DELETE /{namespace}/customers/{id}`	`Customer.deleted`
Customer.activate	`POST /{namespace}/customers/{customer}/activate`	`Customer.activated`
Customer.exempt	`POST /{namespace}/customers/{customer}/exempt`	`Customer.exempted`

Dashboard

Operation	Route	Event
Dashboard.create	`POST /{namespace}/dashboards`	`Dashboard.created`
Dashboard.get	`GET /{namespace}/dashboards/{id}`	None.
Dashboard.list	`GET /{namespace}/dashboards`	None.
Dashboard.update	`PATCH /{namespace}/dashboards/{id}`	`Dashboard.updated`
Dashboard.delete	`DELETE /{namespace}/dashboards/{id}`	`Dashboard.deleted`
Dashboard.ask	`POST /{namespace}/dashboards/ask`	`Dashboard.asked`
Dashboard.schedule	`POST /{namespace}/dashboards/{dashboard}/schedule`	`Dashboard.scheduled`

Dataset

Operation	Route	Event
Dataset.create	`POST /{namespace}/datasets`	`Dataset.created`
Dataset.get	`GET /{namespace}/datasets/{id}`	None.
Dataset.list	`GET /{namespace}/datasets`	None.
Dataset.update	`PATCH /{namespace}/datasets/{id}`	`Dataset.updated`
Dataset.delete	`DELETE /{namespace}/datasets/{id}`	`Dataset.deleted`

Deal

Operation	Route	Event
Deal.create	`POST /{namespace}/deals`	`Deal.created`
Deal.get	`GET /{namespace}/deals/{id}`	None.
Deal.list	`GET /{namespace}/deals`	None.
Deal.update	`PATCH /{namespace}/deals/{id}`	`Deal.updated`
Deal.delete	`DELETE /{namespace}/deals/{id}`	`Deal.deleted`
Deal.advance	`POST /{namespace}/deals/{deal}/advance`	`Deal.advanced`
Deal.assign	`POST /{namespace}/deals/{deal}/assign`	`Deal.assigned`
Deal.lose	`POST /{namespace}/deals/{deal}/lose`	`Deal.lost`
Deal.propose	`POST /{namespace}/deals/{deal}/propose`	`Deal.proposed`
Deal.win	`POST /{namespace}/deals/{deal}/win`	`Deal.won`

Decision

Operation	Route	Event
Decision.create	`POST /{namespace}/decisions`	`Decision.created`
Decision.get	`GET /{namespace}/decisions/{id}`	None.
Decision.list	`GET /{namespace}/decisions`	None.
Decision.supersede	`POST /{namespace}/decisions/{decision}/supersede`	`Decision.superseded`

Demand Budget

Operation	Route	Event
DemandBudget.create	`POST /{namespace}/demand-budgets`	`DemandBudget.created`
DemandBudget.get	`GET /{namespace}/demand-budgets/{id}`	None.
DemandBudget.list	`GET /{namespace}/demand-budgets`	None.
DemandBudget.update	`PATCH /{namespace}/demand-budgets/{id}`	`DemandBudget.updated`

Dispute

Operation	Route	Event
Dispute.get	`GET /{namespace}/disputes/{id}`	None.
Dispute.list	`GET /{namespace}/disputes`	None.
Dispute.accept	`POST /{namespace}/disputes/{dispute}/accept`	`Dispute.accepted`
Dispute.answer	`POST /{namespace}/disputes/{dispute}/answer`	`Dispute.answered`
Dispute.appeal	`POST /{namespace}/disputes/{dispute}/appeal`	`Dispute.appealed`
Dispute.decide	`POST /{namespace}/disputes/{dispute}/decide`	`Dispute.decided`

DNS Record

Operation	Route	Event
DNSRecord.get	`GET /{namespace}/dns-records/{id}`	None.
DNSRecord.list	`GET /{namespace}/dns-records`	None.
DNSRecord.remove	`POST /{namespace}/dns-records/{record}/remove`	`DNSRecord.removed`
DNSRecord.set	`POST /{namespace}/dns-records/set`	`DNSRecord.set`

Document

Operation	Route	Event
Document.create	`POST /{namespace}/documents`	`Document.created`
Document.get	`GET /{namespace}/documents/{id}`	None.
Document.list	`GET /{namespace}/documents`	None.
Document.update	`PATCH /{namespace}/documents/{id}`	`Document.updated`
Document.delete	`DELETE /{namespace}/documents/{id}`	`Document.deleted`
Document.render	`POST /{namespace}/documents/{document}/render`	`Document.rendered`

Domain

Operation	Route	Event
Domain.create	`POST /{namespace}/domains`	`Domain.created`
Domain.get	`GET /{namespace}/domains/{id}`	None.
Domain.list	`GET /{namespace}/domains`	None.
Domain.update	`PATCH /{namespace}/domains/{id}`	`Domain.updated`
Domain.delete	`DELETE /{namespace}/domains/{id}`	`Domain.deleted`
Domain.authenticate	`POST /{namespace}/domains/{domain}/authenticate`	`Domain.authenticated`
Domain.benchmark	`POST /{namespace}/domains/benchmark`	`Domain.benchmarked`
Domain.claim	`POST /{namespace}/domains/claim`	`Domain.claimed`
Domain.connect	`POST /{namespace}/domains/connect`	`Domain.connected`
Domain.register	`POST /{namespace}/domains/register`	`Domain.registered`
Domain.release	`POST /{namespace}/domains/{domain}/release`	`Domain.released`
Domain.renew	`POST /{namespace}/domains/{domain}/renew`	`Domain.renewed`
Domain.search	`POST /{namespace}/domains/search`	`Domain.searched`
Domain.transfer	`POST /{namespace}/domains/{domain}/transfer`	`Domain.transferred`
Domain.verify	`POST /{namespace}/domains/{domain}/verify`	`Domain.verified`

Enrollment

Operation	Route	Event
Enrollment.create	`POST /{namespace}/enrollments`	`Enrollment.created`
Enrollment.get	`GET /{namespace}/enrollments/{id}`	None.
Enrollment.list	`GET /{namespace}/enrollments`	None.
Enrollment.update	`PATCH /{namespace}/enrollments/{id}`	`Enrollment.updated`
Enrollment.delete	`DELETE /{namespace}/enrollments/{id}`	`Enrollment.deleted`
Enrollment.cancel	`POST /{namespace}/enrollments/{enrollment}/cancel`	`Enrollment.canceled`
Enrollment.pause	`POST /{namespace}/enrollments/{enrollment}/pause`	`Enrollment.paused`
Enrollment.resume	`POST /{namespace}/enrollments/{enrollment}/resume`	`Enrollment.resumed`

Entitlement

Operation	Route	Event
Entitlement.create	`POST /{namespace}/entitlements`	`Entitlement.created`
Entitlement.get	`GET /{namespace}/entitlements/{id}`	None.
Entitlement.list	`GET /{namespace}/entitlements`	None.
Entitlement.update	`PATCH /{namespace}/entitlements/{id}`	`Entitlement.updated`
Entitlement.delete	`DELETE /{namespace}/entitlements/{id}`	`Entitlement.deleted`
Entitlement.check	`POST /{namespace}/entitlements/check`	`Entitlement.checked`

Entry

Operation	Route	Event
Entry.get	`GET /{namespace}/entries/{id}`	None.
Entry.list	`GET /{namespace}/entries`	None.
Entry.post	`POST /{namespace}/entries/post`	`Entry.posted`
Entry.settle	`POST /{namespace}/entries/settle`	`Entry.settled`

Evaluator

Operation	Route	Event
Evaluator.create	`POST /{namespace}/evaluators`	`Evaluator.created`
Evaluator.get	`GET /{namespace}/evaluators/{id}`	None.
Evaluator.list	`GET /{namespace}/evaluators`	None.
Evaluator.update	`PATCH /{namespace}/evaluators/{id}`	`Evaluator.updated`
Evaluator.delete	`DELETE /{namespace}/evaluators/{id}`	`Evaluator.deleted`

Event

Operation	Route	Event
Event.create	`POST /{namespace}/events`	`Event.created`
Event.get	`GET /{namespace}/events/{id}`	None.
Event.list	`GET /{namespace}/events`	None.
Event.capture	`POST /{namespace}/events/capture`	`Event.captured`

Evidence

Operation	Route	Event
Evidence.create	`POST /{namespace}/evidence`	`Evidence.created`
Evidence.get	`GET /{namespace}/evidence/{id}`	None.
Evidence.list	`GET /{namespace}/evidence`	None.

Experiment

Operation	Route	Event
Experiment.create	`POST /{namespace}/experiments`	`Experiment.created`
Experiment.get	`GET /{namespace}/experiments/{id}`	None.
Experiment.list	`GET /{namespace}/experiments`	None.
Experiment.conclude	`POST /{namespace}/experiments/{experiment}/conclude`	`Experiment.concluded`
Experiment.start	`POST /{namespace}/experiments/{experiment}/start`	`Experiment.started`

Exposure

Operation	Route	Event
Exposure.create	`POST /{namespace}/exposures`	`Exposure.created`
Exposure.get	`GET /{namespace}/exposures/{id}`	None.
Exposure.list	`GET /{namespace}/exposures`	None.

File

Operation	Route	Event
File.create	`POST /{namespace}/files`	`File.created`
File.get	`GET /{namespace}/files/{id}`	None.
File.list	`GET /{namespace}/files`	None.
File.update	`PATCH /{namespace}/files/{id}`	`File.updated`
File.delete	`DELETE /{namespace}/files/{id}`	`File.deleted`
File.edit	`POST /{namespace}/files/{file}/edit`	`File.edited`
File.generate	`POST /{namespace}/files/generate`	`File.generated`

Flag

Operation	Route	Event
Flag.create	`POST /{namespace}/flags`	`Flag.created`
Flag.get	`GET /{namespace}/flags/{id}`	None.
Flag.list	`GET /{namespace}/flags`	None.
Flag.update	`PATCH /{namespace}/flags/{id}`	`Flag.updated`
Flag.delete	`DELETE /{namespace}/flags/{id}`	`Flag.deleted`
Flag.evaluate	`POST /{namespace}/flags/{flag}/evaluate`	`Flag.evaluated`

Flow

Operation	Route	Event
Flow.create	`POST /{namespace}/flows`	`Flow.created`
Flow.get	`GET /{namespace}/flows/{id}`	None.
Flow.list	`GET /{namespace}/flows`	None.
Flow.update	`PATCH /{namespace}/flows/{id}`	`Flow.updated`
Flow.delete	`DELETE /{namespace}/flows/{id}`	`Flow.deleted`

Forecast

Operation	Route	Event
Forecast.create	`POST /{namespace}/forecasts`	`Forecast.created`
Forecast.get	`GET /{namespace}/forecasts/{id}`	None.
Forecast.list	`GET /{namespace}/forecasts`	None.

Form

Operation	Route	Event
Form.create	`POST /{namespace}/forms`	`Form.created`
Form.get	`GET /{namespace}/forms/{id}`	None.
Form.list	`GET /{namespace}/forms`	None.
Form.update	`PATCH /{namespace}/forms/{id}`	`Form.updated`
Form.delete	`DELETE /{namespace}/forms/{id}`	`Form.deleted`

Function

Operation	Route	Event
Function.create	`POST /{namespace}/functions`	`Function.created`
Function.get	`GET /{namespace}/functions/{id}`	None.
Function.list	`GET /{namespace}/functions`	None.
Function.update	`PATCH /{namespace}/functions/{id}`	`Function.updated`
Function.delete	`DELETE /{namespace}/functions/{id}`	`Function.deleted`

Fund

Operation	Route	Event
Fund.create	`POST /{namespace}/funds`	`Fund.created`
Fund.get	`GET /{namespace}/funds/{id}`	None.
Fund.list	`GET /{namespace}/funds`	None.
Fund.update	`PATCH /{namespace}/funds/{id}`	`Fund.updated`
Fund.delete	`DELETE /{namespace}/funds/{id}`	`Fund.deleted`
Fund.call	`POST /{namespace}/funds/{fund}/call`	`Fund.called`
Fund.distribute	`POST /{namespace}/funds/{fund}/distribute`	`Fund.distributed`
Fund.report	`POST /{namespace}/funds/{fund}/report`	`Fund.reported`

Fund Distribution

Operation	Route	Event
FundDistribution.get	`GET /{namespace}/fund-distributions/{id}`	None.
FundDistribution.list	`GET /{namespace}/fund-distributions`	None.

Funnel

Operation	Route	Event
Funnel.create	`POST /{namespace}/funnels`	`Funnel.created`
Funnel.get	`GET /{namespace}/funnels/{id}`	None.
Funnel.list	`GET /{namespace}/funnels`	None.
Funnel.update	`PATCH /{namespace}/funnels/{id}`	`Funnel.updated`
Funnel.delete	`DELETE /{namespace}/funnels/{id}`	`Funnel.deleted`

Gathering

Operation	Route	Event
Gathering.create	`POST /{namespace}/gatherings`	`Gathering.created`
Gathering.get	`GET /{namespace}/gatherings/{id}`	None.
Gathering.list	`GET /{namespace}/gatherings`	None.
Gathering.update	`PATCH /{namespace}/gatherings/{id}`	`Gathering.updated`
Gathering.delete	`DELETE /{namespace}/gatherings/{id}`	`Gathering.deleted`
Gathering.register	`POST /{namespace}/gatherings/{gathering}/register`	`Gathering.registered`

Goal

Operation	Route	Event
Goal.create	`POST /{namespace}/goals`	`Goal.created`
Goal.get	`GET /{namespace}/goals/{id}`	None.
Goal.list	`GET /{namespace}/goals`	None.
Goal.update	`PATCH /{namespace}/goals/{id}`	`Goal.updated`
Goal.delete	`DELETE /{namespace}/goals/{id}`	`Goal.deleted`

Guard

Operation	Route	Event
Guard.create	`POST /{namespace}/guards`	`Guard.created`
Guard.get	`GET /{namespace}/guards/{id}`	None.
Guard.list	`GET /{namespace}/guards`	None.
Guard.update	`PATCH /{namespace}/guards/{id}`	`Guard.updated`
Guard.delete	`DELETE /{namespace}/guards/{id}`	`Guard.deleted`

Handle

Operation	Route	Event
Handle.create	`POST /{namespace}/handles`	`Handle.created`
Handle.get	`GET /{namespace}/handles/{id}`	None.
Handle.list	`GET /{namespace}/handles`	None.
Handle.update	`PATCH /{namespace}/handles/{id}`	`Handle.updated`
Handle.connect	`POST /{namespace}/handles/{handle}/connect`	`Handle.connected`

Holder

Operation	Route	Event
Holder.create	`POST /{namespace}/holders`	`Holder.created`
Holder.get	`GET /{namespace}/holders/{id}`	None.
Holder.list	`GET /{namespace}/holders`	None.
Holder.update	`PATCH /{namespace}/holders/{id}`	`Holder.updated`

Human

Operation	Route	Event
Human.create	`POST /{namespace}/humans`	`Human.created`
Human.get	`GET /{namespace}/humans/{id}`	None.
Human.list	`GET /{namespace}/humans`	None.
Human.update	`PATCH /{namespace}/humans/{id}`	`Human.updated`
Human.delete	`DELETE /{namespace}/humans/{id}`	`Human.deleted`
Human.hold	`POST /{namespace}/humans/{human}/hold`	`Human.held`
Human.invite	`POST /{namespace}/humans/invite`	`Human.invited`
Human.onboard	`POST /{namespace}/humans/{human}/onboard`	`Human.onboarded`
Human.recruit	`POST /{namespace}/humans/recruit`	`Human.recruited`
Human.release	`POST /{namespace}/humans/{human}/release`	`Human.released`
Human.remit	`POST /{namespace}/humans/{human}/remit`	`Human.remitted`
Human.suspend	`POST /{namespace}/humans/{human}/suspend`	`Human.suspended`

Hypothesis

Operation	Route	Event
Hypothesis.create	`POST /{namespace}/hypotheses`	`Hypothesis.created`
Hypothesis.get	`GET /{namespace}/hypotheses/{id}`	None.
Hypothesis.list	`GET /{namespace}/hypotheses`	None.
Hypothesis.drop	`POST /{namespace}/hypotheses/{hypothesis}/drop`	`Hypothesis.dropped`
Hypothesis.test	`POST /{namespace}/hypotheses/{hypothesis}/test`	`Hypothesis.tested`

ICP

Operation	Route	Event
ICP.create	`POST /{namespace}/icps`	`ICP.created`
ICP.get	`GET /{namespace}/icps/{id}`	None.
ICP.list	`GET /{namespace}/icps`	None.
ICP.update	`PATCH /{namespace}/icps/{id}`	`ICP.updated`
ICP.delete	`DELETE /{namespace}/icps/{id}`	`ICP.deleted`

Idea

Operation	Route	Event
Idea.create	`POST /{namespace}/ideas`	`Idea.created`
Idea.get	`GET /{namespace}/ideas/{id}`	None.
Idea.list	`GET /{namespace}/ideas`	None.
Idea.pursue	`POST /{namespace}/ideas/{idea}/pursue`	`Idea.pursued`

Implementation

Operation	Route	Event
Implementation.create	`POST /{namespace}/implementations`	`Implementation.created`
Implementation.get	`GET /{namespace}/implementations/{id}`	None.
Implementation.list	`GET /{namespace}/implementations`	None.
Implementation.update	`PATCH /{namespace}/implementations/{id}`	`Implementation.updated`
Implementation.delete	`DELETE /{namespace}/implementations/{id}`	`Implementation.deleted`

Incident

Operation	Route	Event
Incident.create	`POST /{namespace}/incidents`	`Incident.created`
Incident.get	`GET /{namespace}/incidents/{id}`	None.
Incident.list	`GET /{namespace}/incidents`	None.
Incident.update	`PATCH /{namespace}/incidents/{id}`	`Incident.updated`
Incident.delete	`DELETE /{namespace}/incidents/{id}`	`Incident.deleted`
Incident.acknowledge	`POST /{namespace}/incidents/{incident}/acknowledge`	`Incident.acknowledged`
Incident.open	`POST /{namespace}/incidents/open`	`Incident.opened`
Incident.resolve	`POST /{namespace}/incidents/{incident}/resolve`	`Incident.resolved`

Instrument

Operation	Route	Event
Instrument.get	`GET /{namespace}/instruments/{id}`	None.
Instrument.list	`GET /{namespace}/instruments`	None.
Instrument.cancel	`POST /{namespace}/instruments/{instrument}/cancel`	`Instrument.canceled`
Instrument.convert	`POST /{namespace}/instruments/{instrument}/convert`	`Instrument.converted`
Instrument.exercise	`POST /{namespace}/instruments/{instrument}/exercise`	`Instrument.exercised`
Instrument.grant	`POST /{namespace}/instruments/grant`	`Instrument.granted`

Integration

Operation	Route	Event
Integration.create	`POST /{namespace}/integrations`	`Integration.created`
Integration.get	`GET /{namespace}/integrations/{id}`	None.
Integration.list	`GET /{namespace}/integrations`	None.
Integration.update	`PATCH /{namespace}/integrations/{id}`	`Integration.updated`
Integration.delete	`DELETE /{namespace}/integrations/{id}`	`Integration.deleted`
Integration.call	`POST /{namespace}/integrations/{integration}/call`	`Integration.called`
Integration.connect	`POST /{namespace}/integrations/connect`	`Integration.connected`
Integration.pause	`POST /{namespace}/integrations/{integration}/pause`	`Integration.paused`
Integration.reconnect	`POST /{namespace}/integrations/{integration}/reconnect`	`Integration.reconnected`
Integration.refresh	`POST /{namespace}/integrations/{integration}/refresh`	`Integration.refreshed`
Integration.resume	`POST /{namespace}/integrations/{integration}/resume`	`Integration.resumed`
Integration.revoke	`POST /{namespace}/integrations/{integration}/revoke`	`Integration.revoked`
Integration.sync	`POST /{namespace}/integrations/{integration}/sync`	`Integration.synced`

Interface

Operation	Route	Event
Interface.create	`POST /{namespace}/interfaces`	`Interface.created`
Interface.get	`GET /{namespace}/interfaces/{id}`	None.
Interface.list	`GET /{namespace}/interfaces`	None.
Interface.update	`PATCH /{namespace}/interfaces/{id}`	`Interface.updated`
Interface.delete	`DELETE /{namespace}/interfaces/{id}`	`Interface.deleted`

Interview

Operation	Route	Event
Interview.create	`POST /{namespace}/interviews`	`Interview.created`
Interview.get	`GET /{namespace}/interviews/{id}`	None.
Interview.list	`GET /{namespace}/interviews`	None.

Invoice

Operation	Route	Event
Invoice.create	`POST /{namespace}/invoices`	`Invoice.created`
Invoice.get	`GET /{namespace}/invoices/{id}`	None.
Invoice.list	`GET /{namespace}/invoices`	None.
Invoice.update	`PATCH /{namespace}/invoices/{id}`	`Invoice.updated`
Invoice.bill	`POST /{namespace}/invoices/{invoice}/bill`	`Invoice.billed`
Invoice.collect	`POST /{namespace}/invoices/{invoice}/collect`	`Invoice.collected`
Invoice.refund	`POST /{namespace}/invoices/{invoice}/refund`	`Invoice.refunded`
Invoice.void	`POST /{namespace}/invoices/{invoice}/void`	`Invoice.voided`

Issue

Operation	Route	Event
Issue.create	`POST /{namespace}/issues`	`Issue.created`
Issue.get	`GET /{namespace}/issues/{id}`	None.
Issue.list	`GET /{namespace}/issues`	None.
Issue.update	`PATCH /{namespace}/issues/{id}`	`Issue.updated`
Issue.delete	`DELETE /{namespace}/issues/{id}`	`Issue.deleted`
Issue.estimate	`POST /{namespace}/issues/{issue}/estimate`	`Issue.estimated`
Issue.reopen	`POST /{namespace}/issues/{issue}/reopen`	`Issue.reopened`
Issue.resolve	`POST /{namespace}/issues/{issue}/resolve`	`Issue.resolved`
Issue.schedule	`POST /{namespace}/issues/{issue}/schedule`	`Issue.scheduled`
Issue.triage	`POST /{namespace}/issues/{issue}/triage`	`Issue.triaged`

Key Result

Operation	Route	Event
KeyResult.create	`POST /{namespace}/key-results`	`KeyResult.created`
KeyResult.get	`GET /{namespace}/key-results/{id}`	None.
KeyResult.list	`GET /{namespace}/key-results`	None.
KeyResult.update	`PATCH /{namespace}/key-results/{id}`	`KeyResult.updated`
KeyResult.delete	`DELETE /{namespace}/key-results/{id}`	`KeyResult.deleted`

Keyword

Operation	Route	Event
Keyword.create	`POST /{namespace}/keywords`	`Keyword.created`
Keyword.get	`GET /{namespace}/keywords/{id}`	None.
Keyword.list	`GET /{namespace}/keywords`	None.
Keyword.update	`PATCH /{namespace}/keywords/{id}`	`Keyword.updated`
Keyword.delete	`DELETE /{namespace}/keywords/{id}`	`Keyword.deleted`
Keyword.measure	`POST /{namespace}/keywords/{keyword}/measure`	`Keyword.measured`

Lead

Operation	Route	Event
Lead.create	`POST /{namespace}/leads`	`Lead.created`
Lead.get	`GET /{namespace}/leads/{id}`	None.
Lead.list	`GET /{namespace}/leads`	None.
Lead.update	`PATCH /{namespace}/leads/{id}`	`Lead.updated`
Lead.delete	`DELETE /{namespace}/leads/{id}`	`Lead.deleted`
Lead.assign	`POST /{namespace}/leads/{lead}/assign`	`Lead.assigned`
Lead.convert	`POST /{namespace}/leads/{lead}/convert`	`Lead.converted`
Lead.disqualify	`POST /{namespace}/leads/{lead}/disqualify`	`Lead.disqualified`
Lead.nurture	`POST /{namespace}/leads/{lead}/nurture`	`Lead.nurtured`
Lead.qualify	`POST /{namespace}/leads/{lead}/qualify`	`Lead.qualified`

Lifecycle

Operation	Route	Event
Lifecycle.get	`GET /{namespace}/lifecycles/{id}`	None.
Lifecycle.list	`GET /{namespace}/lifecycles`	None.
Lifecycle.update	`PATCH /{namespace}/lifecycles/{id}`	`Lifecycle.updated`

Limit

Operation	Route	Event
Limit.create	`POST /{namespace}/limits`	`Limit.created`
Limit.get	`GET /{namespace}/limits/{id}`	None.
Limit.list	`GET /{namespace}/limits`	None.
Limit.update	`PATCH /{namespace}/limits/{id}`	`Limit.updated`
Limit.delete	`DELETE /{namespace}/limits/{id}`	`Limit.deleted`
Limit.raise	`POST /{namespace}/limits/{limit}/raise`	`Limit.raised`

Mailbox

Operation	Route	Event
Mailbox.create	`POST /{namespace}/mailboxes`	`Mailbox.created`
Mailbox.get	`GET /{namespace}/mailboxes/{id}`	None.
Mailbox.list	`GET /{namespace}/mailboxes`	None.
Mailbox.update	`PATCH /{namespace}/mailboxes/{id}`	`Mailbox.updated`
Mailbox.rest	`POST /{namespace}/mailboxes/{mailbox}/rest`	`Mailbox.rested`
Mailbox.retire	`POST /{namespace}/mailboxes/{mailbox}/retire`	`Mailbox.retired`
Mailbox.warm	`POST /{namespace}/mailboxes/{mailbox}/warm`	`Mailbox.warmed`

Mandate

Operation	Route	Event
Mandate.create	`POST /{namespace}/mandates`	`Mandate.created`
Mandate.get	`GET /{namespace}/mandates/{id}`	None.
Mandate.list	`GET /{namespace}/mandates`	None.
Mandate.update	`PATCH /{namespace}/mandates/{id}`	`Mandate.updated`
Mandate.delete	`DELETE /{namespace}/mandates/{id}`	`Mandate.deleted`
Mandate.authorize	`POST /{namespace}/mandates/authorize`	`Mandate.authorized`
Mandate.pause	`POST /{namespace}/mandates/{mandate}/pause`	`Mandate.paused`
Mandate.resume	`POST /{namespace}/mandates/{mandate}/resume`	`Mandate.resumed`
Mandate.revoke	`POST /{namespace}/mandates/{mandate}/revoke`	`Mandate.revoked`
Mandate.spend	`POST /{namespace}/mandates/{mandate}/spend`	`Mandate.spent`

Mapping

Operation	Route	Event
Mapping.create	`POST /{namespace}/mappings`	`Mapping.created`
Mapping.get	`GET /{namespace}/mappings/{id}`	None.
Mapping.list	`GET /{namespace}/mappings`	None.
Mapping.update	`PATCH /{namespace}/mappings/{id}`	`Mapping.updated`
Mapping.delete	`DELETE /{namespace}/mappings/{id}`	`Mapping.deleted`

Market

Operation	Route	Event
Market.create	`POST /{namespace}/markets`	`Market.created`
Market.get	`GET /{namespace}/markets/{id}`	None.
Market.list	`GET /{namespace}/markets`	None.
Market.update	`PATCH /{namespace}/markets/{id}`	`Market.updated`
Market.delete	`DELETE /{namespace}/markets/{id}`	`Market.deleted`
Market.enter	`POST /{namespace}/markets/{market}/enter`	`Market.entered`

Meeting

Operation	Route	Event
Meeting.create	`POST /{namespace}/meetings`	`Meeting.created`
Meeting.get	`GET /{namespace}/meetings/{id}`	None.
Meeting.list	`GET /{namespace}/meetings`	None.
Meeting.update	`PATCH /{namespace}/meetings/{id}`	`Meeting.updated`
Meeting.delete	`DELETE /{namespace}/meetings/{id}`	`Meeting.deleted`
Meeting.book	`POST /{namespace}/meetings/book`	`Meeting.booked`

Member Directory

Operation	Route	Event
MemberDirectory.create	`POST /{namespace}/member-directories`	`MemberDirectory.created`
MemberDirectory.get	`GET /{namespace}/member-directories/{id}`	None.
MemberDirectory.list	`GET /{namespace}/member-directories`	None.
MemberDirectory.update	`PATCH /{namespace}/member-directories/{id}`	`MemberDirectory.updated`
MemberDirectory.deactivate	`POST /{namespace}/member-directories/{directory}/deactivate`	`MemberDirectory.deactivated`
MemberDirectory.deprovision	`POST /{namespace}/member-directories/{directory}/deprovision`	`MemberDirectory.deprovisioned`
MemberDirectory.provision	`POST /{namespace}/member-directories/provision`	`MemberDirectory.provisioned`

Memory

Operation	Route	Event
Memory.create	`POST /{namespace}/memories`	`Memory.created`
Memory.get	`GET /{namespace}/memories/{id}`	None.
Memory.list	`GET /{namespace}/memories`	None.
Memory.update	`PATCH /{namespace}/memories/{id}`	`Memory.updated`
Memory.delete	`DELETE /{namespace}/memories/{id}`	`Memory.deleted`

Message

Operation	Route	Event
Message.create	`POST /{namespace}/messages`	`Message.created`
Message.get	`GET /{namespace}/messages/{id}`	None.
Message.list	`GET /{namespace}/messages`	None.
Message.update	`PATCH /{namespace}/messages/{id}`	`Message.updated`
Message.delete	`DELETE /{namespace}/messages/{id}`	`Message.deleted`
Message.broadcast	`POST /{namespace}/messages/{message}/broadcast`	`Message.broadcasted`
Message.schedule	`POST /{namespace}/messages/{message}/schedule`	`Message.scheduled`

Meter

Operation	Route	Event
Meter.create	`POST /{namespace}/meters`	`Meter.created`
Meter.get	`GET /{namespace}/meters/{id}`	None.
Meter.list	`GET /{namespace}/meters`	None.
Meter.update	`PATCH /{namespace}/meters/{id}`	`Meter.updated`
Meter.delete	`DELETE /{namespace}/meters/{id}`	`Meter.deleted`

Metric

Operation	Route	Event
Metric.create	`POST /{namespace}/metrics`	`Metric.created`
Metric.get	`GET /{namespace}/metrics/{id}`	None.
Metric.list	`GET /{namespace}/metrics`	None.
Metric.update	`PATCH /{namespace}/metrics/{id}`	`Metric.updated`
Metric.delete	`DELETE /{namespace}/metrics/{id}`	`Metric.deleted`
Metric.define	`POST /{namespace}/metrics/define`	`Metric.defined`
Metric.query	`POST /{namespace}/metrics/query`	`Metric.queried`
Metric.watch	`POST /{namespace}/metrics/{metric}/watch`	`Metric.watched`

Minimum Success Criteria

Operation	Route	Event
MinimumSuccessCriteria.create	`POST /{namespace}/minimum-success-criteria`	`MinimumSuccessCriteria.created`
MinimumSuccessCriteria.get	`GET /{namespace}/minimum-success-criteria/{id}`	None.
MinimumSuccessCriteria.list	`GET /{namespace}/minimum-success-criteria`	None.
MinimumSuccessCriteria.update	`PATCH /{namespace}/minimum-success-criteria/{id}`	`MinimumSuccessCriteria.updated`
MinimumSuccessCriteria.delete	`DELETE /{namespace}/minimum-success-criteria/{id}`	`MinimumSuccessCriteria.deleted`

Mode

Operation	Route	Event
Mode.get	`GET /{namespace}/modes/{id}`	None.
Mode.list	`GET /{namespace}/modes`	None.

Monitor

Operation	Route	Event
Monitor.create	`POST /{namespace}/monitors`	`Monitor.created`
Monitor.get	`GET /{namespace}/monitors/{id}`	None.
Monitor.list	`GET /{namespace}/monitors`	None.
Monitor.update	`PATCH /{namespace}/monitors/{id}`	`Monitor.updated`
Monitor.check	`POST /{namespace}/monitors/{monitor}/check`	`Monitor.checked`

Motion

Operation	Route	Event
Motion.get	`GET /{namespace}/motions/{id}`	None.
Motion.list	`GET /{namespace}/motions`	None.

Noun

Operation	Route	Event
Noun.create	`POST /{namespace}/nouns`	`Noun.created`
Noun.get	`GET /{namespace}/nouns/{id}`	None.
Noun.list	`GET /{namespace}/nouns`	None.
Noun.update	`PATCH /{namespace}/nouns/{id}`	`Noun.updated`
Noun.delete	`DELETE /{namespace}/nouns/{id}`	`Noun.deleted`
Noun.retire	`POST /{namespace}/nouns/{noun}/retire`	`Noun.retired`
Noun.trace	`POST /{namespace}/nouns/{noun}/trace`	`Noun.traced`

Offer

Operation	Route	Event
Offer.create	`POST /{namespace}/offers`	`Offer.created`
Offer.get	`GET /{namespace}/offers/{id}`	None.
Offer.list	`GET /{namespace}/offers`	None.
Offer.update	`PATCH /{namespace}/offers/{id}`	`Offer.updated`
Offer.delete	`DELETE /{namespace}/offers/{id}`	`Offer.deleted`
Offer.accept	`POST /{namespace}/offers/{offer}/accept`	`Offer.accepted`
Offer.grant	`POST /{namespace}/offers/{offer}/grant`	`Offer.granted`
Offer.publish	`POST /{namespace}/offers/{offer}/publish`	`Offer.published`
Offer.subscribe	`POST /{namespace}/offers/{offer}/subscribe`	`Offer.subscribed`
Offer.trial	`POST /{namespace}/offers/{offer}/trial`	`Offer.trialed`
Offer.withdraw	`POST /{namespace}/offers/{offer}/withdraw`	`Offer.withdrawn`

Opening

Operation	Route	Event
Opening.create	`POST /{namespace}/openings`	`Opening.created`
Opening.get	`GET /{namespace}/openings/{id}`	None.
Opening.list	`GET /{namespace}/openings`	None.
Opening.update	`PATCH /{namespace}/openings/{id}`	`Opening.updated`
Opening.delete	`DELETE /{namespace}/openings/{id}`	`Opening.deleted`

Order

Operation	Route	Event
Order.create	`POST /{namespace}/orders`	`Order.created`
Order.get	`GET /{namespace}/orders/{id}`	None.
Order.list	`GET /{namespace}/orders`	None.
Order.update	`PATCH /{namespace}/orders/{id}`	`Order.updated`
Order.cancel	`POST /{namespace}/orders/{order}/cancel`	`Order.canceled`
Order.confirm	`POST /{namespace}/orders/{order}/confirm`	`Order.confirmed`
Order.deliver	`POST /{namespace}/orders/{order}/deliver`	`Order.delivered`
Order.dispute	`POST /{namespace}/orders/{order}/dispute`	`Order.disputed`
Order.fulfill	`POST /{namespace}/orders/{order}/fulfill`	`Order.fulfilled`
Order.pay	`POST /{namespace}/orders/{order}/pay`	`Order.paid`
Order.place	`POST /{namespace}/orders/place`	`Order.placed`
Order.refund	`POST /{namespace}/orders/{order}/refund`	`Order.refunded`
Order.revise	`POST /{namespace}/orders/{order}/revise`	`Order.revised`
Order.screen	`POST /{namespace}/orders/{order}/screen`	`Order.screened`
Order.start	`POST /{namespace}/orders/{order}/start`	`Order.started`

Organization

Operation	Route	Event
Organization.create	`POST /{namespace}/organizations`	`Organization.created`
Organization.get	`GET /{namespace}/organizations/{id}`	None.
Organization.list	`GET /{namespace}/organizations`	None.
Organization.update	`PATCH /{namespace}/organizations/{id}`	`Organization.updated`
Organization.delete	`DELETE /{namespace}/organizations/{id}`	`Organization.deleted`
Organization.merge	`POST /{namespace}/organizations/{organization}/merge`	`Organization.merged`

Outcome Contract

Operation	Route	Event
OutcomeContract.get	`GET /{namespace}/outcome-contracts/{id}`	None.
OutcomeContract.list	`GET /{namespace}/outcome-contracts`	None.
OutcomeContract.update	`PATCH /{namespace}/outcome-contracts/{id}`	`OutcomeContract.updated`

Page

Operation	Route	Event
Page.create	`POST /{namespace}/pages`	`Page.created`
Page.get	`GET /{namespace}/pages/{id}`	None.
Page.list	`GET /{namespace}/pages`	None.
Page.update	`PATCH /{namespace}/pages/{id}`	`Page.updated`
Page.delete	`DELETE /{namespace}/pages/{id}`	`Page.deleted`

Partner

Operation	Route	Event
Partner.create	`POST /{namespace}/partners`	`Partner.created`
Partner.get	`GET /{namespace}/partners/{id}`	None.
Partner.list	`GET /{namespace}/partners`	None.
Partner.update	`PATCH /{namespace}/partners/{id}`	`Partner.updated`
Partner.delete	`DELETE /{namespace}/partners/{id}`	`Partner.deleted`

Party

Operation	Route	Event
Party.create	`POST /{namespace}/parties`	`Party.created`
Party.get	`GET /{namespace}/parties/{id}`	None.
Party.list	`GET /{namespace}/parties`	None.
Party.update	`PATCH /{namespace}/parties/{id}`	`Party.updated`
Party.delete	`DELETE /{namespace}/parties/{id}`	`Party.deleted`
Party.screen	`POST /{namespace}/parties/{party}/screen`	`Party.screened`

Pay Run

Operation	Route	Event
PayRun.get	`GET /{namespace}/pay-runs/{id}`	None.
PayRun.list	`GET /{namespace}/pay-runs`	None.
PayRun.approve	`POST /{namespace}/pay-runs/{payRun}/approve`	`PayRun.approved`
PayRun.pay	`POST /{namespace}/pay-runs/{payRun}/pay`	`PayRun.paid`
PayRun.prepare	`POST /{namespace}/pay-runs/prepare`	`PayRun.prepared`
PayRun.void	`POST /{namespace}/pay-runs/{payRun}/void`	`PayRun.voided`

Payment Source

Operation	Route	Event
PaymentSource.get	`GET /{namespace}/payment-sources/{id}`	None.
PaymentSource.list	`GET /{namespace}/payment-sources`	None.
PaymentSource.update	`PATCH /{namespace}/payment-sources/{id}`	`PaymentSource.updated`
PaymentSource.add	`POST /{namespace}/payment-sources/add`	`PaymentSource.added`
PaymentSource.remove	`POST /{namespace}/payment-sources/{paymentSource}/remove`	`PaymentSource.removed`

Period

Operation	Route	Event
Period.get	`GET /{namespace}/periods/{id}`	None.
Period.list	`GET /{namespace}/periods`	None.
Period.update	`PATCH /{namespace}/periods/{id}`	`Period.updated`
Period.close	`POST /{namespace}/periods/{period}/close`	`Period.closed`
Period.lock	`POST /{namespace}/periods/{period}/lock`	`Period.locked`
Period.recognize	`POST /{namespace}/periods/{period}/recognize`	`Period.recognized`

Permission

Operation	Route	Event
Permission.create	`POST /{namespace}/permissions`	`Permission.created`
Permission.get	`GET /{namespace}/permissions/{id}`	None.
Permission.list	`GET /{namespace}/permissions`	None.
Permission.update	`PATCH /{namespace}/permissions/{id}`	`Permission.updated`
Permission.delete	`DELETE /{namespace}/permissions/{id}`	`Permission.deleted`

Person

Operation	Route	Event
Person.create	`POST /{namespace}/people`	`Person.created`
Person.get	`GET /{namespace}/people/{id}`	None.
Person.list	`GET /{namespace}/people`	None.
Person.update	`PATCH /{namespace}/people/{id}`	`Person.updated`
Person.delete	`DELETE /{namespace}/people/{id}`	`Person.deleted`

Persona

Operation	Route	Event
Persona.create	`POST /{namespace}/personas`	`Persona.created`
Persona.get	`GET /{namespace}/personas/{id}`	None.
Persona.list	`GET /{namespace}/personas`	None.
Persona.update	`PATCH /{namespace}/personas/{id}`	`Persona.updated`
Persona.delete	`DELETE /{namespace}/personas/{id}`	`Persona.deleted`

Play

Operation	Route	Event
Play.create	`POST /{namespace}/plays`	`Play.created`
Play.get	`GET /{namespace}/plays/{id}`	None.
Play.list	`GET /{namespace}/plays`	None.
Play.update	`PATCH /{namespace}/plays/{id}`	`Play.updated`
Play.delete	`DELETE /{namespace}/plays/{id}`	`Play.deleted`
Play.apply	`POST /{namespace}/plays/{play}/apply`	`Play.applied`

Play Mix

Operation	Route	Event
PlayMix.get	`GET /{namespace}/play-mixes/{id}`	None.
PlayMix.list	`GET /{namespace}/play-mixes`	None.
PlayMix.compile	`POST /{namespace}/play-mixes/compile`	`PlayMix.compiled`

Policy

Operation	Route	Event
Policy.create	`POST /{namespace}/policies`	`Policy.created`
Policy.get	`GET /{namespace}/policies/{id}`	None.
Policy.list	`GET /{namespace}/policies`	None.
Policy.update	`PATCH /{namespace}/policies/{id}`	`Policy.updated`
Policy.delete	`DELETE /{namespace}/policies/{id}`	`Policy.deleted`

Portal

Operation	Route	Event
Portal.create	`POST /{namespace}/portals`	`Portal.created`
Portal.get	`GET /{namespace}/portals/{id}`	None.
Portal.list	`GET /{namespace}/portals`	None.
Portal.update	`PATCH /{namespace}/portals/{id}`	`Portal.updated`
Portal.delete	`DELETE /{namespace}/portals/{id}`	`Portal.deleted`

Portfolio

Operation	Route	Event
Portfolio.create	`POST /{namespace}/portfolios`	`Portfolio.created`
Portfolio.get	`GET /{namespace}/portfolios/{id}`	None.
Portfolio.list	`GET /{namespace}/portfolios`	None.
Portfolio.update	`PATCH /{namespace}/portfolios/{id}`	`Portfolio.updated`
Portfolio.delete	`DELETE /{namespace}/portfolios/{id}`	`Portfolio.deleted`
Portfolio.brake	`POST /{namespace}/portfolios/{portfolio}/brake`	`Portfolio.braked`
Portfolio.lift	`POST /{namespace}/portfolios/{portfolio}/lift`	`Portfolio.lifted`

Post

Operation	Route	Event
Post.create	`POST /{namespace}/posts`	`Post.created`
Post.get	`GET /{namespace}/posts/{id}`	None.
Post.list	`GET /{namespace}/posts`	None.
Post.update	`PATCH /{namespace}/posts/{id}`	`Post.updated`
Post.publish	`POST /{namespace}/posts/{post}/publish`	`Post.published`
Post.schedule	`POST /{namespace}/posts/{post}/schedule`	`Post.scheduled`
Post.withdraw	`POST /{namespace}/posts/{post}/withdraw`	`Post.withdrawn`

Problem

Operation	Route	Event
Problem.create	`POST /{namespace}/problems`	`Problem.created`
Problem.get	`GET /{namespace}/problems/{id}`	None.
Problem.list	`GET /{namespace}/problems`	None.
Problem.update	`PATCH /{namespace}/problems/{id}`	`Problem.updated`
Problem.delete	`DELETE /{namespace}/problems/{id}`	`Problem.deleted`
Problem.rank	`POST /{namespace}/problems/rank`	`Problem.ranked`
Problem.suggest	`POST /{namespace}/problems/suggest`	`Problem.suggested`

Process

Operation	Route	Event
Process.create	`POST /{namespace}/processes`	`Process.created`
Process.get	`GET /{namespace}/processes/{id}`	None.
Process.list	`GET /{namespace}/processes`	None.
Process.update	`PATCH /{namespace}/processes/{id}`	`Process.updated`
Process.delete	`DELETE /{namespace}/processes/{id}`	`Process.deleted`
Process.enable	`POST /{namespace}/processes/{process}/enable`	`Process.enabled`
Process.pause	`POST /{namespace}/processes/{process}/pause`	`Process.paused`

Product

Operation	Route	Event
Product.create	`POST /{namespace}/products`	`Product.created`
Product.get	`GET /{namespace}/products/{id}`	None.
Product.list	`GET /{namespace}/products`	None.
Product.update	`PATCH /{namespace}/products/{id}`	`Product.updated`
Product.delete	`DELETE /{namespace}/products/{id}`	`Product.deleted`

Product Template

Operation	Route	Event
ProductTemplate.create	`POST /{namespace}/product-templates`	`ProductTemplate.created`
ProductTemplate.get	`GET /{namespace}/product-templates/{id}`	None.
ProductTemplate.list	`GET /{namespace}/product-templates`	None.
ProductTemplate.update	`PATCH /{namespace}/product-templates/{id}`	`ProductTemplate.updated`
ProductTemplate.delete	`DELETE /{namespace}/product-templates/{id}`	`ProductTemplate.deleted`

Project

Operation	Route	Event
Project.create	`POST /{namespace}/projects`	`Project.created`
Project.get	`GET /{namespace}/projects/{id}`	None.
Project.list	`GET /{namespace}/projects`	None.
Project.update	`PATCH /{namespace}/projects/{id}`	`Project.updated`
Project.delete	`DELETE /{namespace}/projects/{id}`	`Project.deleted`

Proof

Operation	Route	Event
Proof.get	`GET /{namespace}/proofs/{id}`	None.
Proof.list	`GET /{namespace}/proofs`	None.

Prospect

Operation	Route	Event
Prospect.create	`POST /{namespace}/prospects`	`Prospect.created`
Prospect.get	`GET /{namespace}/prospects/{id}`	None.
Prospect.list	`GET /{namespace}/prospects`	None.
Prospect.update	`PATCH /{namespace}/prospects/{id}`	`Prospect.updated`
Prospect.delete	`DELETE /{namespace}/prospects/{id}`	`Prospect.deleted`
Prospect.engage	`POST /{namespace}/prospects/{prospect}/engage`	`Prospect.engaged`

Publication

Operation	Route	Event
Publication.get	`GET /{namespace}/publications/{id}`	None.
Publication.list	`GET /{namespace}/publications`	None.

Purpose

Operation	Route	Event
Purpose.create	`POST /{namespace}/purposes`	`Purpose.created`
Purpose.get	`GET /{namespace}/purposes/{id}`	None.
Purpose.list	`GET /{namespace}/purposes`	None.
Purpose.update	`PATCH /{namespace}/purposes/{id}`	`Purpose.updated`
Purpose.delete	`DELETE /{namespace}/purposes/{id}`	`Purpose.deleted`

Question

Operation	Route	Event
Question.get	`GET /{namespace}/questions/{id}`	None.
Question.list	`GET /{namespace}/questions`	None.

Quote

Operation	Route	Event
Quote.create	`POST /{namespace}/quotes`	`Quote.created`
Quote.get	`GET /{namespace}/quotes/{id}`	None.
Quote.list	`GET /{namespace}/quotes`	None.
Quote.update	`PATCH /{namespace}/quotes/{id}`	`Quote.updated`
Quote.delete	`DELETE /{namespace}/quotes/{id}`	`Quote.deleted`
Quote.accept	`POST /{namespace}/quotes/{quote}/accept`	`Quote.accepted`
Quote.decline	`POST /{namespace}/quotes/{quote}/decline`	`Quote.declined`
Quote.expire	`POST /{namespace}/quotes/{quote}/expire`	`Quote.expired`
Quote.request	`POST /{namespace}/quotes/request`	`Quote.requested`
Quote.send	`POST /{namespace}/quotes/{quote}/send`	`Quote.sent`
Quote.supersede	`POST /{namespace}/quotes/{quote}/supersede`	`Quote.superseded`

Readout

Operation	Route	Event
Readout.create	`POST /{namespace}/readouts`	`Readout.created`
Readout.get	`GET /{namespace}/readouts/{id}`	None.
Readout.list	`GET /{namespace}/readouts`	None.
Readout.update	`PATCH /{namespace}/readouts/{id}`	`Readout.updated`
Readout.delete	`DELETE /{namespace}/readouts/{id}`	`Readout.deleted`

Recording

Operation	Route	Event
Recording.get	`GET /{namespace}/recordings/{id}`	None.
Recording.list	`GET /{namespace}/recordings`	None.

Recovery Objective

Operation	Route	Event
RecoveryObjective.create	`POST /{namespace}/recovery-objectives`	`RecoveryObjective.created`
RecoveryObjective.get	`GET /{namespace}/recovery-objectives/{id}`	None.
RecoveryObjective.list	`GET /{namespace}/recovery-objectives`	None.
RecoveryObjective.update	`PATCH /{namespace}/recovery-objectives/{id}`	`RecoveryObjective.updated`
RecoveryObjective.delete	`DELETE /{namespace}/recovery-objectives/{id}`	`RecoveryObjective.deleted`
RecoveryObjective.drill	`POST /{namespace}/recovery-objectives/{objective}/drill`	`RecoveryObjective.drilled`

Referral

Operation	Route	Event
Referral.create	`POST /{namespace}/referrals`	`Referral.created`
Referral.get	`GET /{namespace}/referrals/{id}`	None.
Referral.list	`GET /{namespace}/referrals`	None.
Referral.update	`PATCH /{namespace}/referrals/{id}`	`Referral.updated`
Referral.delete	`DELETE /{namespace}/referrals/{id}`	`Referral.deleted`

Registration

Operation	Route	Event
Registration.create	`POST /{namespace}/registrations`	`Registration.created`
Registration.get	`GET /{namespace}/registrations/{id}`	None.
Registration.list	`GET /{namespace}/registrations`	None.
Registration.update	`PATCH /{namespace}/registrations/{id}`	`Registration.updated`
Registration.delete	`DELETE /{namespace}/registrations/{id}`	`Registration.deleted`
Registration.admit	`POST /{namespace}/registrations/{registration}/admit`	`Registration.admitted`
Registration.approve	`POST /{namespace}/registrations/{registration}/approve`	`Registration.approved`
Registration.attend	`POST /{namespace}/registrations/{registration}/attend`	`Registration.attended`

Relationship

Operation	Route	Event
Relationship.create	`POST /{namespace}/relationships`	`Relationship.created`
Relationship.get	`GET /{namespace}/relationships/{id}`	None.
Relationship.list	`GET /{namespace}/relationships`	None.
Relationship.update	`PATCH /{namespace}/relationships/{id}`	`Relationship.updated`
Relationship.delete	`DELETE /{namespace}/relationships/{id}`	`Relationship.deleted`

Renewal

Operation	Route	Event
Renewal.create	`POST /{namespace}/renewals`	`Renewal.created`
Renewal.get	`GET /{namespace}/renewals/{id}`	None.
Renewal.list	`GET /{namespace}/renewals`	None.
Renewal.update	`PATCH /{namespace}/renewals/{id}`	`Renewal.updated`
Renewal.delete	`DELETE /{namespace}/renewals/{id}`	`Renewal.deleted`
Renewal.open	`POST /{namespace}/renewals/open`	`Renewal.opened`

Reserved Act

Operation	Route	Event
ReservedAct.create	`POST /{namespace}/reserved-acts`	`ReservedAct.created`
ReservedAct.get	`GET /{namespace}/reserved-acts/{id}`	None.
ReservedAct.list	`GET /{namespace}/reserved-acts`	None.
ReservedAct.update	`PATCH /{namespace}/reserved-acts/{id}`	`ReservedAct.updated`
ReservedAct.delete	`DELETE /{namespace}/reserved-acts/{id}`	`ReservedAct.deleted`

Review

Operation	Route	Event
Review.create	`POST /{namespace}/reviews`	`Review.created`
Review.get	`GET /{namespace}/reviews/{id}`	None.
Review.list	`GET /{namespace}/reviews`	None.
Review.update	`PATCH /{namespace}/reviews/{id}`	`Review.updated`
Review.publish	`POST /{namespace}/reviews/{review}/publish`	`Review.published`
Review.remove	`POST /{namespace}/reviews/{review}/remove`	`Review.removed`
Review.withhold	`POST /{namespace}/reviews/{review}/withhold`	`Review.withheld`

Risk

Operation	Route	Event
Risk.create	`POST /{namespace}/risks`	`Risk.created`
Risk.get	`GET /{namespace}/risks/{id}`	None.
Risk.list	`GET /{namespace}/risks`	None.
Risk.update	`PATCH /{namespace}/risks/{id}`	`Risk.updated`
Risk.accept	`POST /{namespace}/risks/{risk}/accept`	`Risk.accepted`
Risk.assess	`POST /{namespace}/risks/{risk}/assess`	`Risk.assessed`
Risk.close	`POST /{namespace}/risks/{risk}/close`	`Risk.closed`
Risk.treat	`POST /{namespace}/risks/{risk}/treat`	`Risk.treated`

Role

Operation	Route	Event
Role.create	`POST /{namespace}/roles`	`Role.created`
Role.get	`GET /{namespace}/roles/{id}`	None.
Role.list	`GET /{namespace}/roles`	None.
Role.update	`PATCH /{namespace}/roles/{id}`	`Role.updated`
Role.delete	`DELETE /{namespace}/roles/{id}`	`Role.deleted`
Role.review	`POST /{namespace}/roles/{role}/review`	`Role.reviewed`
Role.staff	`POST /{namespace}/roles/{role}/staff`	`Role.staffed`
Role.vacate	`POST /{namespace}/roles/{role}/vacate`	`Role.vacated`

Role Review

Operation	Route	Event
RoleReview.get	`GET /{namespace}/role-reviews/{id}`	None.
RoleReview.list	`GET /{namespace}/role-reviews`	None.

Screening

Operation	Route	Event
Screening.get	`GET /{namespace}/screenings/{id}`	None.
Screening.list	`GET /{namespace}/screenings`	None.

Secret

Operation	Route	Event
Secret.get	`GET /{namespace}/secrets/{id}`	None.
Secret.list	`GET /{namespace}/secrets`	None.
Secret.revoke	`POST /{namespace}/secrets/{secret}/revoke`	`Secret.revoked`
Secret.rotate	`POST /{namespace}/secrets/{secret}/rotate`	`Secret.rotated`
Secret.store	`POST /{namespace}/secrets/store`	`Secret.stored`

Sequence

Operation	Route	Event
Sequence.create	`POST /{namespace}/sequences`	`Sequence.created`
Sequence.get	`GET /{namespace}/sequences/{id}`	None.
Sequence.list	`GET /{namespace}/sequences`	None.
Sequence.update	`PATCH /{namespace}/sequences/{id}`	`Sequence.updated`
Sequence.delete	`DELETE /{namespace}/sequences/{id}`	`Sequence.deleted`

Service

Operation	Route	Event
Service.create	`POST /{namespace}/services`	`Service.created`
Service.get	`GET /{namespace}/services/{id}`	None.
Service.list	`GET /{namespace}/services`	None.
Service.update	`PATCH /{namespace}/services/{id}`	`Service.updated`
Service.delete	`DELETE /{namespace}/services/{id}`	`Service.deleted`

Setting

Operation	Route	Event
Setting.create	`POST /{namespace}/settings`	`Setting.created`
Setting.get	`GET /{namespace}/settings/{id}`	None.
Setting.list	`GET /{namespace}/settings`	None.
Setting.update	`PATCH /{namespace}/settings/{id}`	`Setting.updated`
Setting.delete	`DELETE /{namespace}/settings/{id}`	`Setting.deleted`

Operation	Route	Event
Share.get	`GET /{namespace}/shares/{id}`	None.
Share.list	`GET /{namespace}/shares`	None.
Share.issue	`POST /{namespace}/shares/issue`	`Share.issued`
Share.transfer	`POST /{namespace}/shares/{share}/transfer`	`Share.transferred`

Site

Operation	Route	Event
Site.create	`POST /{namespace}/sites`	`Site.created`
Site.get	`GET /{namespace}/sites/{id}`	None.
Site.list	`GET /{namespace}/sites`	None.
Site.update	`PATCH /{namespace}/sites/{id}`	`Site.updated`
Site.delete	`DELETE /{namespace}/sites/{id}`	`Site.deleted`
Site.publish	`POST /{namespace}/sites/{site}/publish`	`Site.published`

Skill

Operation	Route	Event
Skill.create	`POST /{namespace}/skills`	`Skill.created`
Skill.get	`GET /{namespace}/skills/{id}`	None.
Skill.list	`GET /{namespace}/skills`	None.
Skill.update	`PATCH /{namespace}/skills/{id}`	`Skill.updated`
Skill.delete	`DELETE /{namespace}/skills/{id}`	`Skill.deleted`

Software

Operation	Route	Event
Software.create	`POST /{namespace}/software`	`Software.created`
Software.get	`GET /{namespace}/software/{id}`	None.
Software.list	`GET /{namespace}/software`	None.
Software.update	`PATCH /{namespace}/software/{id}`	`Software.updated`
Software.delete	`DELETE /{namespace}/software/{id}`	`Software.deleted`

Source

Operation	Route	Event
Source.create	`POST /{namespace}/sources`	`Source.created`
Source.get	`GET /{namespace}/sources/{id}`	None.
Source.list	`GET /{namespace}/sources`	None.
Source.update	`PATCH /{namespace}/sources/{id}`	`Source.updated`
Source.delete	`DELETE /{namespace}/sources/{id}`	`Source.deleted`

SSO Connection

Operation	Route	Event
SSOConnection.create	`POST /{namespace}/sso-connections`	`SSOConnection.created`
SSOConnection.get	`GET /{namespace}/sso-connections/{id}`	None.
SSOConnection.list	`GET /{namespace}/sso-connections`	None.
SSOConnection.update	`PATCH /{namespace}/sso-connections/{id}`	`SSOConnection.updated`
SSOConnection.activate	`POST /{namespace}/sso-connections/{connection}/activate`	`SSOConnection.activated`
SSOConnection.deactivate	`POST /{namespace}/sso-connections/{connection}/deactivate`	`SSOConnection.deactivated`

Standard

Operation	Route	Event
Standard.get	`GET /{namespace}/standards/{id}`	None.
Standard.list	`GET /{namespace}/standards`	None.

Startup

Operation	Route	Event
Startup.create	`POST /{namespace}/startups`	`Startup.created`
Startup.get	`GET /{namespace}/startups/{id}`	None.
Startup.list	`GET /{namespace}/startups`	None.
Startup.update	`PATCH /{namespace}/startups/{id}`	`Startup.updated`
Startup.delete	`DELETE /{namespace}/startups/{id}`	`Startup.deleted`
Startup.advance	`POST /{namespace}/startups/{startup}/advance`	`Startup.advanced`
Startup.build	`POST /{namespace}/startups/{startup}/build`	`Startup.built`
Startup.claim	`POST /{namespace}/startups/{startup}/claim`	`Startup.claimed`
Startup.clone	`POST /{namespace}/startups/{startup}/clone`	`Startup.cloned`
Startup.graduate	`POST /{namespace}/startups/{startup}/graduate`	`Startup.graduated`
Startup.hold	`POST /{namespace}/startups/{startup}/hold`	`Startup.held`
Startup.import	`POST /{namespace}/startups/import`	`Startup.imported`
Startup.launch	`POST /{namespace}/startups/{startup}/launch`	`Startup.launched`
Startup.pause	`POST /{namespace}/startups/{startup}/pause`	`Startup.paused`
Startup.pivot	`POST /{namespace}/startups/{startup}/pivot`	`Startup.pivoted`
Startup.read	`POST /{namespace}/startups/{startup}/read`	`Startup.read`
Startup.resume	`POST /{namespace}/startups/{startup}/resume`	`Startup.resumed`
Startup.sell	`POST /{namespace}/startups/{startup}/sell`	`Startup.sold`

Startup Template

Operation	Route	Event
StartupTemplate.create	`POST /{namespace}/startup-templates`	`StartupTemplate.created`
StartupTemplate.get	`GET /{namespace}/startup-templates/{id}`	None.
StartupTemplate.list	`GET /{namespace}/startup-templates`	None.
StartupTemplate.update	`PATCH /{namespace}/startup-templates/{id}`	`StartupTemplate.updated`
StartupTemplate.delete	`DELETE /{namespace}/startup-templates/{id}`	`StartupTemplate.deleted`
StartupTemplate.extend	`POST /{namespace}/startup-templates/{startupTemplate}/extend`	`StartupTemplate.extended`
StartupTemplate.promote	`POST /{namespace}/startup-templates/{startupTemplate}/promote`	`StartupTemplate.promoted`
StartupTemplate.upgrade	`POST /{namespace}/startup-templates/{startupTemplate}/upgrade`	`StartupTemplate.upgraded`

Statement

Operation	Route	Event
Statement.get	`GET /{namespace}/statements/{id}`	None.
Statement.list	`GET /{namespace}/statements`	None.

Story

Operation	Route	Event
Story.create	`POST /{namespace}/stories`	`Story.created`
Story.get	`GET /{namespace}/stories/{id}`	None.
Story.list	`GET /{namespace}/stories`	None.
Story.update	`PATCH /{namespace}/stories/{id}`	`Story.updated`
Story.delete	`DELETE /{namespace}/stories/{id}`	`Story.deleted`

Studio

Operation	Route	Event
Studio.create	`POST /{namespace}/studios`	`Studio.created`
Studio.get	`GET /{namespace}/studios/{id}`	None.
Studio.list	`GET /{namespace}/studios`	None.
Studio.update	`PATCH /{namespace}/studios/{id}`	`Studio.updated`
Studio.delete	`DELETE /{namespace}/studios/{id}`	`Studio.deleted`

Subscription

Operation	Route	Event
Subscription.create	`POST /{namespace}/subscriptions`	`Subscription.created`
Subscription.get	`GET /{namespace}/subscriptions/{id}`	None.
Subscription.list	`GET /{namespace}/subscriptions`	None.
Subscription.update	`PATCH /{namespace}/subscriptions/{id}`	`Subscription.updated`
Subscription.keep	`POST /{namespace}/subscriptions/{subscription}/keep`	`Subscription.kept`
Subscription.pause	`POST /{namespace}/subscriptions/{subscription}/pause`	`Subscription.paused`
Subscription.renew	`POST /{namespace}/subscriptions/{subscription}/renew`	`Subscription.renewed`
Subscription.resize	`POST /{namespace}/subscriptions/{subscription}/resize`	`Subscription.resized`
Subscription.resume	`POST /{namespace}/subscriptions/{subscription}/resume`	`Subscription.resumed`
Subscription.switch	`POST /{namespace}/subscriptions/{subscription}/switch`	`Subscription.switched`
Subscription.unsubscribe	`POST /{namespace}/subscriptions/{subscription}/unsubscribe`	`Subscription.unsubscribed`

Supplier

Operation	Route	Event
Supplier.create	`POST /{namespace}/suppliers`	`Supplier.created`
Supplier.get	`GET /{namespace}/suppliers/{id}`	None.
Supplier.list	`GET /{namespace}/suppliers`	None.
Supplier.update	`PATCH /{namespace}/suppliers/{id}`	`Supplier.updated`
Supplier.delete	`DELETE /{namespace}/suppliers/{id}`	`Supplier.deleted`

Suppression

Operation	Route	Event
Suppression.create	`POST /{namespace}/suppressions`	`Suppression.created`
Suppression.get	`GET /{namespace}/suppressions/{id}`	None.
Suppression.list	`GET /{namespace}/suppressions`	None.

Survey

Operation	Route	Event
Survey.create	`POST /{namespace}/surveys`	`Survey.created`
Survey.get	`GET /{namespace}/surveys/{id}`	None.
Survey.list	`GET /{namespace}/surveys`	None.
Survey.update	`PATCH /{namespace}/surveys/{id}`	`Survey.updated`
Survey.delete	`DELETE /{namespace}/surveys/{id}`	`Survey.deleted`

System

Operation	Route	Event
System.create	`POST /{namespace}/systems`	`System.created`
System.get	`GET /{namespace}/systems/{id}`	None.
System.list	`GET /{namespace}/systems`	None.
System.update	`PATCH /{namespace}/systems/{id}`	`System.updated`
System.delete	`DELETE /{namespace}/systems/{id}`	`System.deleted`

Task

Operation	Route	Event
Task.create	`POST /{namespace}/tasks`	`Task.created`
Task.get	`GET /{namespace}/tasks/{id}`	None.
Task.list	`GET /{namespace}/tasks`	None.
Task.update	`PATCH /{namespace}/tasks/{id}`	`Task.updated`
Task.delete	`DELETE /{namespace}/tasks/{id}`	`Task.deleted`
Task.assign	`POST /{namespace}/tasks/{task}/assign`	`Task.assigned`
Task.claim	`POST /{namespace}/tasks/{task}/claim`	`Task.claimed`
Task.complete	`POST /{namespace}/tasks/{task}/complete`	`Task.completed`
Task.delegate	`POST /{namespace}/tasks/{task}/delegate`	`Task.delegated`
Task.escalate	`POST /{namespace}/tasks/{task}/escalate`	`Task.escalated`
Task.next	`POST /{namespace}/tasks/next`	`Task.offered`
Task.return	`POST /{namespace}/tasks/{task}/return`	`Task.returned`

Team

Operation	Route	Event
Team.create	`POST /{namespace}/teams`	`Team.created`
Team.get	`GET /{namespace}/teams/{id}`	None.
Team.list	`GET /{namespace}/teams`	None.
Team.update	`PATCH /{namespace}/teams/{id}`	`Team.updated`
Team.delete	`DELETE /{namespace}/teams/{id}`	`Team.deleted`

Template

Operation	Route	Event
Template.create	`POST /{namespace}/templates`	`Template.created`
Template.get	`GET /{namespace}/templates/{id}`	None.
Template.list	`GET /{namespace}/templates`	None.
Template.update	`PATCH /{namespace}/templates/{id}`	`Template.updated`
Template.delete	`DELETE /{namespace}/templates/{id}`	`Template.deleted`
Template.extend	`POST /{namespace}/templates/{template}/extend`	`Template.extended`
Template.promote	`POST /{namespace}/templates/{template}/promote`	`Template.promoted`
Template.upgrade	`POST /{namespace}/templates/{template}/upgrade`	`Template.upgraded`

Tenant

Operation	Route	Event
Tenant.create	`POST /{namespace}/tenants`	`Tenant.created`
Tenant.get	`GET /{namespace}/tenants/{id}`	None.
Tenant.list	`GET /{namespace}/tenants`	None.
Tenant.update	`PATCH /{namespace}/tenants/{id}`	`Tenant.updated`
Tenant.delete	`DELETE /{namespace}/tenants/{id}`	`Tenant.deleted`
Tenant.invite	`POST /{namespace}/tenants/{tenant}/invite`	`Tenant.invited`
Tenant.pin	`POST /{namespace}/tenants/{tenant}/pin`	`Tenant.pinned`
Tenant.provision	`POST /{namespace}/tenants/provision`	`Tenant.provisioned`
Tenant.requestSetup	`POST /{namespace}/tenants/{tenant}/requestSetup`	`Tenant.setupRequested`

Theme

Operation	Route	Event
Theme.create	`POST /{namespace}/themes`	`Theme.created`
Theme.get	`GET /{namespace}/themes/{id}`	None.
Theme.list	`GET /{namespace}/themes`	None.
Theme.update	`PATCH /{namespace}/themes/{id}`	`Theme.updated`
Theme.delete	`DELETE /{namespace}/themes/{id}`	`Theme.deleted`

Thing

Operation	Route	Event
Thing.create	`POST /{namespace}/things`	`Thing.created`
Thing.get	`GET /{namespace}/things/{id}`	None.
Thing.list	`GET /{namespace}/things`	None.
Thing.update	`PATCH /{namespace}/things/{id}`	`Thing.updated`
Thing.delete	`DELETE /{namespace}/things/{id}`	`Thing.deleted`
Thing.relate	`POST /{namespace}/things/{thing}/relate`	`Thing.related`
Thing.resolve	`POST /{namespace}/things/resolve`	`Thing.resolved`
Thing.share	`POST /{namespace}/things/{thing}/share`	`Thing.shared`
Thing.unrelate	`POST /{namespace}/things/{thing}/unrelate`	`Thing.unrelated`

Thread

Operation	Route	Event
Thread.create	`POST /{namespace}/threads`	`Thread.created`
Thread.get	`GET /{namespace}/threads/{id}`	None.
Thread.list	`GET /{namespace}/threads`	None.
Thread.update	`PATCH /{namespace}/threads/{id}`	`Thread.updated`
Thread.delete	`DELETE /{namespace}/threads/{id}`	`Thread.deleted`

Tool

Operation	Route	Event
Tool.create	`POST /{namespace}/tools`	`Tool.created`
Tool.get	`GET /{namespace}/tools/{id}`	None.
Tool.list	`GET /{namespace}/tools`	None.
Tool.update	`PATCH /{namespace}/tools/{id}`	`Tool.updated`
Tool.delete	`DELETE /{namespace}/tools/{id}`	`Tool.deleted`

Transaction

Operation	Route	Event
Transaction.get	`GET /{namespace}/transactions/{id}`	None.
Transaction.list	`GET /{namespace}/transactions`	None.
Transaction.attach	`POST /{namespace}/transactions/{transaction}/attach`	`Transaction.attached`
Transaction.categorize	`POST /{namespace}/transactions/{transaction}/categorize`	`Transaction.categorized`
Transaction.reconcile	`POST /{namespace}/transactions/{transaction}/reconcile`	`Transaction.reconciled`

Trigger

Operation	Route	Event
Trigger.create	`POST /{namespace}/triggers`	`Trigger.created`
Trigger.get	`GET /{namespace}/triggers/{id}`	None.
Trigger.list	`GET /{namespace}/triggers`	None.
Trigger.update	`PATCH /{namespace}/triggers/{id}`	`Trigger.updated`
Trigger.delete	`DELETE /{namespace}/triggers/{id}`	`Trigger.deleted`

Variant

Operation	Route	Event
Variant.create	`POST /{namespace}/variants`	`Variant.created`
Variant.get	`GET /{namespace}/variants/{id}`	None.
Variant.list	`GET /{namespace}/variants`	None.
Variant.update	`PATCH /{namespace}/variants/{id}`	`Variant.updated`
Variant.delete	`DELETE /{namespace}/variants/{id}`	`Variant.deleted`

Verb

Operation	Route	Event
Verb.create	`POST /{namespace}/verbs`	`Verb.created`
Verb.get	`GET /{namespace}/verbs/{id}`	None.
Verb.list	`GET /{namespace}/verbs`	None.
Verb.update	`PATCH /{namespace}/verbs/{id}`	`Verb.updated`
Verb.delete	`DELETE /{namespace}/verbs/{id}`	`Verb.deleted`
Verb.retire	`POST /{namespace}/verbs/{verb}/retire`	`Verb.retired`

Version

Operation	Route	Event
Version.get	`GET /{namespace}/versions/{id}`	None.
Version.list	`GET /{namespace}/versions`	None.
Version.deploy	`POST /{namespace}/versions/{version}/deploy`	`Version.deployed`

Video

Operation	Route	Event
Video.create	`POST /{namespace}/videos`	`Video.created`
Video.get	`GET /{namespace}/videos/{id}`	None.
Video.list	`GET /{namespace}/videos`	None.
Video.update	`PATCH /{namespace}/videos/{id}`	`Video.updated`
Video.draft	`POST /{namespace}/videos/draft`	`Video.drafted`
Video.finalize	`POST /{namespace}/videos/{video}/finalize`	`Video.finalized`

Visit

Operation	Route	Event
Visit.get	`GET /{namespace}/visits/{id}`	None.
Visit.list	`GET /{namespace}/visits`	None.

Visitor

Operation	Route	Event
Visitor.create	`POST /{namespace}/visitors`	`Visitor.created`
Visitor.get	`GET /{namespace}/visitors/{id}`	None.
Visitor.list	`GET /{namespace}/visitors`	None.
Visitor.update	`PATCH /{namespace}/visitors/{id}`	`Visitor.updated`
Visitor.delete	`DELETE /{namespace}/visitors/{id}`	`Visitor.deleted`
Visitor.forget	`POST /{namespace}/visitors/{visitor}/forget`	`Visitor.forgotten`
Visitor.identify	`POST /{namespace}/visitors/{visitor}/identify`	`Visitor.identified`
Visitor.merge	`POST /{namespace}/visitors/{visitor}/merge`	`Visitor.merged`

Voice

Operation	Route	Event
Voice.get	`GET /{namespace}/voices/{id}`	None.
Voice.list	`GET /{namespace}/voices`	None.
Voice.update	`PATCH /{namespace}/voices/{id}`	`Voice.updated`
Voice.clone	`POST /{namespace}/voices/clone`	`Voice.cloned`
Voice.retire	`POST /{namespace}/voices/{voice}/retire`	`Voice.retired`

Waitlist

Operation	Route	Event
Waitlist.create	`POST /{namespace}/waitlists`	`Waitlist.created`
Waitlist.get	`GET /{namespace}/waitlists/{id}`	None.
Waitlist.list	`GET /{namespace}/waitlists`	None.
Waitlist.update	`PATCH /{namespace}/waitlists/{id}`	`Waitlist.updated`
Waitlist.delete	`DELETE /{namespace}/waitlists/{id}`	`Waitlist.deleted`
Waitlist.admit	`POST /{namespace}/waitlists/{waitlist}/admit`	`Waitlist.admitted`
Waitlist.join	`POST /{namespace}/waitlists/{waitlist}/join`	`Waitlist.joined`

Watch

Operation	Route	Event
Watch.create	`POST /{namespace}/watches`	`Watch.created`
Watch.get	`GET /{namespace}/watches/{id}`	None.
Watch.list	`GET /{namespace}/watches`	None.
Watch.update	`PATCH /{namespace}/watches/{id}`	`Watch.updated`
Watch.delete	`DELETE /{namespace}/watches/{id}`	`Watch.deleted`
Watch.pause	`POST /{namespace}/watches/{watch}/pause`	`Watch.paused`
Watch.replay	`POST /{namespace}/watches/{watch}/replay`	`Watch.replayed`
Watch.resume	`POST /{namespace}/watches/{watch}/resume`	`Watch.resumed`
Watch.rotate	`POST /{namespace}/watches/{watch}/rotate`	`Watch.rotated`

Worker

Operation	Route	Event
Worker.create	`POST /{namespace}/workers`	`Worker.created`
Worker.get	`GET /{namespace}/workers/{id}`	None.
Worker.list	`GET /{namespace}/workers`	None.
Worker.update	`PATCH /{namespace}/workers/{id}`	`Worker.updated`
Worker.delete	`DELETE /{namespace}/workers/{id}`	`Worker.deleted`

Workflow

Operation	Route	Event
Workflow.create	`POST /{namespace}/workflows`	`Workflow.created`
Workflow.get	`GET /{namespace}/workflows/{id}`	None.
Workflow.list	`GET /{namespace}/workflows`	None.
Workflow.update	`PATCH /{namespace}/workflows/{id}`	`Workflow.updated`
Workflow.delete	`DELETE /{namespace}/workflows/{id}`	`Workflow.deleted`

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