@lantharos/pult 0.0.0-stage → 0.8.0

package/index.d.mts

@@ -0,0 +1,950 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region ../protocol/src/wire.d.ts
+interface Actor {
+  type: "user" | "agent" | "triage" | "app" | "schedule" | "guard";
+  id: string;
+  name: string;
+  role: string | null;
+}
+interface SendResult {
+  id: string;
+  created: boolean;
+  reopened: boolean;
+  occurrences: number;
+}
+interface ActionResult {
+  message?: string;
+  blocks?: Block[];
+  running?: boolean;
+}
+interface IncomingMessage {
+  thread: string;
+  from: string;
+  subject?: string;
+  text: string;
+}
+type TriageDecision = {
+  type: "state";
+  state: string;
+} | {
+  type: "run";
+  action: string;
+  input?: Record<string, unknown>;
+} | {
+  type: "tag";
+  tag: string;
+};
+//#endregion
+//#region ../protocol/src/flags.d.ts
+interface Ramp {
+  of: "rollout" | "value";
+  from: number;
+  to: number;
+  start: number;
+  end: number;
+  every: number | null;
+  whole: boolean;
+}
+type Attribute = string | number | boolean;
+interface Condition {
+  attribute: string;
+  op: "is" | "is not" | "above" | "below";
+  values: Attribute[];
+}
+interface FlagRule {
+  conditions: Condition[];
+  value: unknown;
+  rollout: number | null;
+}
+interface FlagValue {
+  value: unknown;
+  rollout: number | null;
+  targets: Record<string, unknown>;
+  rules: FlagRule[];
+  ramp: Ramp | null;
+}
+interface FlagUsage {
+  reads: number;
+  lastReadAt: number | null;
+}
+interface FlagState extends FlagValue {
+  titles: Record<string, string>;
+  updatedAt: number | null;
+  updatedBy: Actor | null;
+  usage: FlagUsage;
+}
+//#endregion
+//#region ../protocol/src/status.d.ts
+type ComponentState = "operational" | "degraded" | "partial" | "down" | "maintenance";
+//#endregion
+//#region ../protocol/src/console.d.ts
+interface ItemSummary {
+  id: string;
+  inbox: string;
+  title: string;
+  state: string;
+  record: string | null;
+  tags: string[];
+  assignee: string | null;
+  snoozedUntil: number | null;
+  occurrences: number;
+  users: number;
+  firstSeen: number;
+  lastSeen: number;
+  updatedAt: number;
+  unread: boolean;
+  triage: "pending" | "done" | null;
+  autoHandled: boolean;
+  dueAt: number | null;
+  fields: Record<string, FieldValue>;
+}
+//#endregion
+//#region ../protocol/src/blocks.d.ts
+type FieldValue = string | number | boolean | null | {
+  date: string;
+} | {
+  record: RecordRef;
+} | {
+  code: string;
+} | {
+  live: LiveStat;
+} | {
+  sensitive: Sensitive;
+} | {
+  edit: Editable;
+};
+interface Editable {
+  value: FieldValue;
+  action: string;
+  record: string | null;
+  field: string | null;
+}
+interface Sensitive {
+  value?: string;
+  hint?: string;
+  index?: number;
+}
+type LiveStat = "occurrences" | "users" | "firstSeen" | "lastSeen" | "due";
+interface RecordRef {
+  resource: string;
+  id: string;
+  title?: string;
+}
+type ChartRange = "1h" | "24h" | "7d" | "30d";
+interface ChartPoint {
+  at: number;
+  value: number;
+}
+interface ActionButton {
+  action: string;
+  record: string | null;
+  input?: Record<string, unknown>;
+  label?: string;
+}
+type Block = {
+  type: "markdown";
+  text: string;
+} | {
+  type: "fields";
+  fields: {
+    label: string;
+    value: FieldValue;
+  }[];
+} | {
+  type: "code";
+  code: string;
+  lang?: string;
+  title?: string;
+} | {
+  type: "chart";
+  metric: "occurrences";
+  range: ChartRange;
+  title?: string;
+} | {
+  type: "chart";
+  points: ChartPoint[];
+  title?: string;
+} | {
+  type: "chart";
+  inbox: string;
+  range: ChartRange;
+  title?: string;
+  points?: ChartPoint[];
+} | {
+  type: "attachment";
+  name: string;
+  url?: string;
+  key?: string;
+  contentType?: string;
+  size?: number;
+} | {
+  type: "record";
+  ref: RecordRef;
+} | {
+  type: "timeline";
+  entries: {
+    at: number;
+    text: string;
+  }[];
+} | {
+  type: "table";
+  columns: string[];
+  rows: FieldValue[][];
+} | {
+  type: "stats";
+  stats: {
+    label: string;
+    value: FieldValue;
+    note?: string;
+  }[];
+} | {
+  type: "actions";
+  actions: ActionButton[];
+} | {
+  type: "form";
+  form: ActionButton;
+} | {
+  type: "columns";
+  columns: Block[][];
+} | {
+  type: "count";
+  label: string;
+  inbox: string;
+  filter: ViewFilter;
+  view: string | null;
+  value?: number;
+} | {
+  type: "items";
+  label: string;
+  inbox: string;
+  filter: ViewFilter;
+  sort: Sort;
+  view: string | null;
+  limit: number;
+  items?: ItemSummary[];
+} | {
+  type: "flag";
+  flag: string;
+  state?: FlagState;
+};
+//#endregion
+//#region ../protocol/src/manifest.d.ts
+type JsonSchema = {
+  type?: string | string[];
+  title?: string;
+  description?: string;
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  items?: JsonSchema;
+  enum?: unknown[];
+  const?: unknown;
+  format?: string;
+  default?: unknown;
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number;
+  exclusiveMaximum?: number;
+  minLength?: number;
+  maxLength?: number;
+  anyOf?: JsonSchema[];
+  oneOf?: JsonSchema[];
+  [key: string]: unknown;
+};
+type Danger = "none" | "confirm" | "reauth";
+type Layout = "list" | "table" | "board";
+interface ActionDef {
+  source: string;
+  label: string;
+  description?: string;
+  danger: Danger;
+  input: JsonSchema | null;
+  preview: boolean;
+  automatable: boolean;
+  approval: boolean;
+  contextual: boolean;
+  background: boolean;
+  pick: Record<string, string>;
+  choices: string[];
+  schedule: Schedule | null;
+}
+interface Schedule {
+  cron: string;
+  timezone: string | null;
+}
+interface RelationDef {
+  resource: string;
+  label: string;
+}
+interface ResourceDef {
+  source: string;
+  label: string;
+  plural: string;
+  icon: string;
+  searchable: boolean;
+  list: {
+    filters: JsonSchema | null;
+  } | null;
+  related: Record<string, RelationDef>;
+  actions: Record<string, ActionDef>;
+}
+type TriageQuestion = {
+  type: "noul";
+  prompt: string;
+  criteria?: string;
+} | {
+  type: "choice";
+  prompt: string;
+  options: Record<string, string>;
+} | {
+  type: "score";
+  prompt: string;
+  levels: string[];
+};
+interface TriageRuleDef {
+  name: string;
+  live: boolean;
+  then: TriageDecision[];
+}
+interface TriageDef {
+  instructions: string;
+  questions: Record<string, TriageQuestion>;
+  rules: TriageRuleDef[];
+}
+interface InboxDef {
+  source: string;
+  label: string;
+  icon: string;
+  resource: string | null;
+  layout: Layout;
+  states: string[];
+  closed: string[];
+  reopen: string[];
+  data: JsonSchema | null;
+  columns: string[];
+  intake: {
+    title: string;
+    description?: string;
+  } | null;
+  triage: TriageDef | null;
+  reply: boolean;
+  hooks: {
+    state: boolean;
+  };
+  sla: Record<string, number>;
+}
+interface ViewFilter {
+  state?: string[];
+  tags?: string[];
+  assignee?: "me" | "none";
+  triaged?: boolean;
+  search?: string;
+}
+type SortKey = "lastSeen" | "firstSeen" | "occurrences" | "users" | "title" | "due";
+type Sort = SortKey | `-${SortKey}`;
+interface ViewDef {
+  source: string;
+  label: string;
+  inbox: string;
+  filter: ViewFilter;
+  layout: Layout;
+  columns: string[];
+  sort: Sort;
+}
+interface RoleDef {
+  source: string;
+  label: string;
+  inboxes: string[];
+  resources: string[];
+  actions: string[];
+  pages: string[];
+  flags: string[];
+  reveal: boolean;
+  status: boolean;
+}
+interface PageDef {
+  source: string;
+  label: string;
+  icon: string;
+  params: JsonSchema | null;
+  blocks: Block[] | null;
+}
+interface FlagDef {
+  source: string;
+  label: string;
+  description?: string;
+  value: JsonSchema;
+  default: unknown;
+  target: string | null;
+  attributes: JsonSchema | null;
+  guards: FlagGuard[];
+  danger: Danger;
+  approval: boolean;
+}
+interface FlagGuard {
+  inbox: string;
+  perHour: number;
+  then: "pause" | "revert";
+}
+type NotifyTrigger = "created" | "reopened" | "overdue" | {
+  spike: number;
+};
+type Recipient = {
+  role: string;
+} | {
+  channel: string;
+};
+interface NotifyDef {
+  source: string;
+  inboxes: string[];
+  on: NotifyTrigger[];
+  to: Recipient[];
+}
+interface StatusComponentDef {
+  label: string;
+  description: string | null;
+  monitored: boolean;
+  check: string | null;
+}
+interface StatusLogo {
+  light: string;
+  dark: string;
+}
+interface StatusDef {
+  source: string;
+  title: string;
+  logo: StatusLogo | null;
+  website: string | null;
+  css: string | null;
+  components: Record<string, StatusComponentDef>;
+  alert: Recipient[];
+  after: number;
+}
+type Delivery = {
+  mode: "socket";
+} | {
+  mode: "webhook";
+  path: string;
+};
+interface Manifest {
+  project: string;
+  version: string;
+  environments: string[];
+  sync: string;
+  delivery: Delivery;
+  resources: Record<string, ResourceDef>;
+  actions: Record<string, ActionDef>;
+  inboxes: Record<string, InboxDef>;
+  views: Record<string, ViewDef>;
+  pages: Record<string, PageDef>;
+  flags: Record<string, FlagDef>;
+  roles: Record<string, RoleDef>;
+  notify: Record<string, NotifyDef>;
+  status: StatusDef | null;
+}
+//#endregion
+//#region src/schema.d.ts
+type Schema<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output>;
+type AnySchema = StandardSchemaV1<any, any>;
+type InferInput<S> = S extends Schema<infer I, unknown> ? I : never;
+type InferOutput<S> = S extends Schema<unknown, infer O> ? O : never;
+export declare class ValidationError extends Error {
+  readonly issues: readonly StandardSchemaV1.Issue[];
+  constructor(issues: readonly StandardSchemaV1.Issue[]);
+}
+//#endregion
+//#region src/define/source.d.ts
+declare const KIND: unique symbol;
+type Kind = "resource" | "action" | "inbox" | "role" | "view" | "page" | "flag" | "notify" | "status" | "config";
+interface Located {
+  readonly [KIND]: Kind;
+  readonly origin: Origin;
+}
+interface Origin {
+  file: string;
+  line: number;
+}
+//#endregion
+//#region src/define/resource.d.ts
+type Awaitable$2<T> = T | Promise<T>;
+interface ActionContext<R, I> {
+  record: R;
+  input: I;
+  actor: Actor;
+  item: string | null;
+  progress: (fraction: number | null, note?: string) => Promise<void>;
+}
+type ActionReturn = undefined | string | ActionResult;
+type ActionInput$1<S> = S extends AnySchema ? InferOutput<S> : Record<string, never>;
+type ChoiceInput = string | {
+  value: string;
+  label: string;
+};
+interface ActionOptions<R, S> {
+  label?: string;
+  description?: string;
+  input?: S;
+  danger?: Danger;
+  automatable?: boolean;
+  approval?: boolean;
+  background?: boolean;
+  when?: (record: R) => boolean;
+  defaults?: (record: R) => Partial<ActionInput$1<S>>;
+  pick?: { [K in keyof ActionInput$1<S>]?: string; };
+  choices?: { [K in keyof ActionInput$1<S>]?: (record: R) => Awaitable$2<ChoiceInput[]>; };
+  preview?: (context: ActionContext<R, ActionInput$1<S>>) => Awaitable$2<BlockInput[]>;
+  run: (context: ActionContext<R, ActionInput$1<S>>) => Awaitable$2<ActionReturn>;
+}
+interface ActionRef {
+  readonly id: string;
+}
+type ScheduleInput = string | {
+  cron: string;
+  timezone?: string;
+};
+interface StandaloneOptions<S> extends Omit<ActionOptions<null, S>, "when"> {
+  schedule?: ScheduleInput;
+}
+interface Action<R = any, S = any> extends Located, ActionRef {
+  readonly options: ActionOptions<R, S> & {
+    schedule?: ScheduleInput;
+  };
+  readonly resource: string | null;
+  readonly name: string;
+}
+export declare function action<S extends AnySchema | undefined = undefined>(name: string, options: StandaloneOptions<S>): Action<null, S>;
+type ActionFactory<R> = <S extends AnySchema | undefined = undefined>(options: ActionOptions<R, S>) => ActionOptions<R, S>;
+interface Relation<R = any> {
+  resource: string;
+  label?: string;
+  list: (record: R, limit: number) => Awaitable$2<unknown[]>;
+}
+interface ListQuery<F> {
+  query: string;
+  filters: F;
+  cursor: string | null;
+  limit: number;
+}
+interface ListOptions<R, F extends AnySchema | undefined> {
+  filters?: F;
+  run: (query: ListQuery<F extends AnySchema ? InferOutput<F> : Record<string, never>>) => Awaitable$2<{
+    records: R[];
+    cursor?: string | null;
+  }>;
+}
+interface ResourceOptions<R, A, F extends AnySchema | undefined> {
+  get: (id: string) => Awaitable$2<R | null | undefined>;
+  find?: (query: string, limit: number) => Awaitable$2<R[]>;
+  list?: ListOptions<R, F>;
+  id?: (record: R) => string;
+  title: (record: R) => string;
+  subtitle?: (record: R) => string | undefined;
+  fields?: (record: R) => Record<string, FieldInput>;
+  url?: (record: R) => string | undefined;
+  render?: (record: R) => Awaitable$2<BlockInput[]>;
+  label?: string;
+  plural?: string;
+  icon?: string;
+  related?: Record<string, Relation<R>>;
+  actions?: (action: ActionFactory<R>) => A;
+}
+type Actions<R, A> = { readonly [K in keyof A]: A[K] extends ActionOptions<R, infer S> ? Action<R, S> : never; } & {
+  readonly "*": ActionRef;
+};
+interface Resource<R = any, A = any> extends Located {
+  readonly name: string;
+  readonly options: ResourceOptions<R, A, any>;
+  readonly actions: Actions<R, A>;
+}
+export declare function resource<R, A extends Record<string, unknown> = Record<never, never>, F extends AnySchema | undefined = undefined>(name: string, options: ResourceOptions<R, A, F>): Resource<R, A>;
+//#endregion
+//#region src/define/triage.d.ts
+declare const answer: unique symbol;
+type Question<T> = TriageQuestion & {
+  readonly [answer]?: T;
+};
+export declare function noul(prompt: string, criteria?: string): Question<number>;
+export declare function choice<const O extends string>(options: readonly O[] | Record<O, string>, prompt: string): Question<O>;
+export declare function score(levels: readonly string[], prompt: string): Question<number>;
+type Answers<Q extends Record<string, Question<unknown>>> = { [K in keyof Q]: Q[K] extends Question<infer T> ? T : never; } & {
+  confidence: number;
+};
+interface Rule<A> {
+  name?: string;
+  live?: boolean;
+  when: (answers: A) => boolean;
+  then: TriageDecision | TriageDecision[];
+}
+interface Triage<Q extends Record<string, Question<unknown>> = Record<string, Question<unknown>>> {
+  instructions: string;
+  questions: Q;
+  rules: Rule<Answers<Q>>[];
+}
+export declare function triage<Q extends Record<string, Question<unknown>>>(options: {
+  instructions?: string;
+  questions: Q;
+  rules?: Rule<Answers<Q>>[];
+}): Triage<Q>;
+export declare const setState: (state: string) => TriageDecision;
+export declare const tag: (name: string) => TriageDecision;
+export declare const run: (action: ActionRef, input?: Record<string, unknown>) => TriageDecision;
+//#endregion
+//#region src/define/inbox.d.ts
+type Awaitable$1<T> = T | Promise<T>;
+type Duration = `${number}${"m" | "h" | "d"}`;
+interface ItemView<D> {
+  title: string;
+  data: D;
+  record: string | null;
+  occurrences: FieldValue;
+  users: FieldValue;
+  firstSeen: FieldValue;
+  lastSeen: FieldValue;
+  due: FieldValue;
+}
+interface InboxOptions<S extends Schema | undefined> {
+  label?: string;
+  icon?: string;
+  resource?: Resource;
+  layout?: Layout;
+  states?: string[];
+  closed?: string[];
+  reopenOn?: "new-occurrence";
+  reopenFrom?: string[];
+  data?: S;
+  title?: (data: InboxData<S>) => string;
+  render?: (item: ItemView<InboxData<S>>) => Awaitable$1<BlockInput[]>;
+  columns?: string[];
+  intake?: boolean | {
+    title?: string;
+    description?: string;
+  };
+  triage?: Triage<any>;
+  reply?: {
+    to: (item: ItemView<InboxData<S>>) => string | undefined;
+    send: (email: OutgoingEmail<InboxData<S>>) => Awaitable$1<void>;
+  };
+  onState?: (change: StateChange<InboxData<S>>) => Awaitable$1<void>;
+  sla?: Record<string, Duration>;
+}
+interface OutgoingEmail<D> {
+  item: {
+    id: string;
+    title: string;
+    record: string | null;
+    data: D;
+  };
+  to: string;
+  subject: string;
+  text: string;
+  thread: string;
+  actor: Actor;
+}
+interface StateChange<D> {
+  item: {
+    id: string;
+    title: string;
+    record: string | null;
+    data: D;
+  };
+  from: string;
+  to: string;
+  actor: Actor;
+}
+type InboxData<S> = S extends Schema ? InferOutput<S> : Record<string, unknown>;
+type InboxInput<S> = S extends Schema ? InferInput<S> : Record<string, unknown>;
+interface Inbox<S extends Schema | undefined = any> extends Located {
+  readonly name: string;
+  readonly options: InboxOptions<S>;
+  readonly states: string[];
+  readonly closed: string[];
+}
+export declare function inbox<S extends Schema | undefined = undefined>(name: string, options: InboxOptions<S>): Inbox<S>;
+//#endregion
+//#region src/define/flag.d.ts
+interface Guard {
+  inbox: Inbox;
+  perHour: number;
+  then?: "pause" | "revert";
+}
+interface FlagOptionsBase<A> {
+  label?: string;
+  description?: string;
+  target?: Resource;
+  attributes?: A;
+  guard?: Guard | Guard[];
+  danger?: Danger;
+  approval?: boolean;
+}
+type Attributes<A> = A extends AnySchema ? Partial<InferOutput<A>> : Record<string, Attribute | null | undefined>;
+type FlagContext<A> = {
+  key?: string;
+} & Attributes<A>;
+interface Flag<T = unknown, A = unknown> extends Located {
+  readonly name: string;
+  readonly options: FlagOptionsBase<AnySchema> & {
+    value?: AnySchema;
+    default: T;
+  };
+  readonly context?: FlagContext<A>;
+}
+export declare function flag<A extends AnySchema | undefined = undefined>(name: string, options?: FlagOptionsBase<A> & {
+  default?: boolean;
+}): Flag<boolean, A>;
+export declare function flag<S extends AnySchema, A extends AnySchema | undefined = undefined>(name: string, options: FlagOptionsBase<A> & {
+  value: S;
+  default: InferOutput<S>;
+}): Flag<InferOutput<S>, A>;
+//#endregion
+//#region src/define/page.d.ts
+type Awaitable<T> = T | Promise<T>;
+type Filter = Omit<ViewFilter, "state"> & {
+  state?: string | string[];
+};
+interface ViewOptions {
+  label?: string;
+  inbox: Inbox;
+  filter?: Filter;
+  layout?: Layout;
+  columns?: string[];
+  sort?: Sort;
+}
+interface View extends Located {
+  readonly name: string;
+  readonly options: ViewOptions;
+}
+export declare function view(name: string, options: ViewOptions): View;
+type Params<P> = P extends AnySchema ? InferOutput<P> : Record<string, never>;
+interface PageContext<P> {
+  params: P;
+  actor: Actor;
+}
+type PageContent<P> = BlockInput[] | ((context: PageContext<Params<P>>) => Awaitable<BlockInput[]>);
+interface PageOptions<P extends AnySchema | undefined> {
+  label?: string;
+  icon?: string;
+  params?: P;
+  render: PageContent<P>;
+}
+interface Page extends Located {
+  readonly name: string;
+  readonly options: PageOptions<any>;
+}
+export declare function page<P extends AnySchema | undefined = undefined>(name: string, options: PageOptions<P>): Page;
+export declare function home<P extends AnySchema | undefined = undefined>(options: PageContent<P> | PageOptions<P>): Page;
+//#endregion
+//#region src/blocks.d.ts
+type FieldInput = FieldValue | Date | undefined;
+interface PendingAttachment {
+  type: "attachment";
+  name: string;
+  contentType: string;
+  data: Blob | ArrayBuffer | Uint8Array;
+}
+type BlockInput = Block | PendingAttachment;
+type ResourceLike = string | {
+  readonly name: string;
+};
+type Points = {
+  at: Date | number;
+  value: number;
+}[];
+declare function chart(metric: "occurrences", options?: {
+  range?: ChartRange;
+  title?: string;
+}): Block;
+declare function chart(points: Points, options?: {
+  title?: string;
+}): Block;
+declare function chart(inbox: Inbox, options?: {
+  range?: ChartRange;
+  title?: string;
+}): Block;
+type Listing = Inbox | View;
+type ActionInput = ActionRef | string;
+type ButtonInput = ActionInput | {
+  action: ActionInput;
+  record?: string;
+  input?: Record<string, unknown>;
+  label?: string;
+};
+export declare const b: {
+  markdown: (text: string) => Block;
+  fields: (fields: Record<string, FieldInput>) => Block;
+  code: (code: string, options?: {
+    lang?: string;
+    title?: string;
+  }) => Block;
+  chart: typeof chart;
+  attachment: (attachment: {
+    name: string;
+    url: string;
+    contentType?: string;
+    size?: number;
+  } | Omit<PendingAttachment, "type">) => BlockInput;
+  record: (resource: ResourceLike, id: string, title?: string) => Block;
+  ref: (resource: ResourceLike, id: string, title?: string) => FieldValue;
+  sensitive: (value: string | number, options?: {
+    hint?: string;
+  }) => FieldValue;
+  timeline: (entries: {
+    at: Date | number;
+    text: string;
+  }[]) => Block;
+  table: (rows: Record<string, FieldInput>[], columns?: string[]) => Block;
+  stats: (stats: Record<string, FieldInput | {
+    value: FieldInput;
+    note?: string;
+  }>) => Block;
+  actions: (...buttons: ButtonInput[]) => Block;
+  form: (action: ButtonInput) => Block;
+  columns: (...columns: BlockInput[][]) => Block;
+  count: (target: Listing, options?: {
+    filter?: Filter;
+    label?: string;
+  }) => Block;
+  items: (target: Listing, options?: {
+    filter?: Filter;
+    label?: string;
+    limit?: number;
+  }) => Block;
+  flag: (flag: Flag<any>) => Block;
+  edit: (value: FieldInput, action: ActionInput, options?: {
+    record?: string;
+    field?: string;
+  }) => FieldValue;
+};
+//#endregion
+//#region src/define/config.d.ts
+interface ConfigOptions {
+  project: string;
+  include: string[];
+  delivery?: Delivery;
+  environments?: string[];
+  sync?: string;
+}
+interface Config extends Located {
+  readonly options: Required<ConfigOptions>;
+}
+export declare function defineConfig(options: ConfigOptions): Config;
+//#endregion
+//#region src/define/role.d.ts
+interface RoleOptions {
+  label?: string;
+  inboxes?: Inbox[];
+  resources?: Resource[];
+  actions?: ActionRef[];
+  pages?: Page[];
+  flags?: Flag<any>[];
+  reveal?: boolean;
+  status?: boolean;
+}
+interface Role extends Located {
+  readonly name: string;
+  readonly options: RoleOptions;
+}
+export declare function role(name: string, options: RoleOptions): Role;
+//#endregion
+//#region src/define/notify.d.ts
+interface Channel {
+  readonly channel: string;
+}
+export declare function slack(channel: string): Channel;
+interface NotifyOptions {
+  inboxes: Inbox[];
+  on: NotifyTrigger[];
+  to: (Role | Channel)[];
+}
+interface Notify extends Located {
+  readonly name: string;
+  readonly options: NotifyOptions;
+}
+export declare function notify(name: string, options: NotifyOptions): Notify;
+//#endregion
+//#region src/define/status.d.ts
+interface StatusComponent {
+  label: string;
+  description?: string;
+  monitored?: boolean;
+  check?: string;
+}
+interface StatusOptions {
+  title?: string;
+  logo?: string | {
+    light: string;
+    dark: string;
+  };
+  website?: string;
+  css?: string;
+  components: Record<string, string | StatusComponent>;
+  alert?: (Role | Channel)[];
+  after?: Duration;
+}
+interface Status extends Located {
+  readonly options: StatusOptions;
+}
+export declare function status(options: StatusOptions): Status;
+//#endregion
+//#region src/client/dispatch.d.ts
+interface Project {
+  manifest: Manifest;
+  modules: Record<string, () => Promise<Record<string, unknown>>>;
+}
+//#endregion
+//#region src/client/transport.d.ts
+type Fetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export declare class PultError extends Error {
+  readonly status: number;
+  readonly code?: string | undefined;
+  constructor(message: string, status: number, code?: string | undefined);
+}
+//#endregion
+//#region src/client/socket.d.ts
+interface Connection {
+  close(): void;
+}
+//#endregion
+//#region src/client/pult.d.ts
+interface PultOptions {
+  key?: string;
+  project: Project;
+  url?: string;
+  fetch?: Fetch;
+}
+interface SendOptions<S extends Schema | undefined> {
+  title?: string;
+  fingerprint?: string;
+  record?: string;
+  data: InboxInput<S>;
+  tags?: string[];
+  suggest?: {
+    action: ActionRef;
+    input?: Record<string, unknown>;
+    reason?: string;
+  }[];
+}
+export declare function createPult({ key, project, url, fetch }: PultOptions): {
+  send: <S extends Schema | undefined>(inbox: Inbox<S>, item: SendOptions<S>) => Promise<SendResult>;
+  log: (resource: Resource, id: string, text: string, options?: {
+    blocks?: BlockInput[];
+    by?: string;
+  }) => Promise<void>;
+  receive: (message: IncomingMessage) => Promise<{
+    item: string;
+  } | null>;
+  flag: <T, A>(definition: Flag<T, A>, context?: string | FlagContext<A>) => Promise<T>;
+  status: {
+    set(component: string, state: ComponentState): Promise<void>;
+  };
+  listen: (options?: {
+    onStatus?: (status: "connected" | "disconnected") => void;
+  }) => Connection;
+  handler: () => (request: Request, context?: {
+    waitUntil(work: Promise<unknown>): void;
+  }) => Promise<Response>;
+  deploy: () => Promise<{
+    version: string;
+  }>;
+};
+type Pult = ReturnType<typeof createPult>;
+//#endregion
+export type { Action, ActionContext, Actor, Block, Channel, ComponentState, Config, Duration, Flag, Inbox, ItemView, ListQuery, Manifest, Notify, OutgoingEmail, Page, PageContext, Project, Pult, Relation, Resource, Role, SendOptions, SendResult, StateChange, Status, View };