Files
yaak-mountain-loop/crates-proxy/yaak-proxy-lib/bindings/gen_rpc.ts
T
Gregory SchierandClaude Fable 5.2 35058cc3be Yaak Proxy: prose pass over the UI copy
Apply the approved wording table: labels stay short, explanations are one
full sentence about the user's traffic, and detail moves behind an info
icon on the first-run card, the body banners, the Settings Helper row and
the rejected card. One word per thing: traffic and flows, recorded,
truncated, domains, searches, the CLI, Retry.

Backend messages that reach the window change with them, with the tests
and harness fixtures that assert on the old text. The two working files
for the pass are removed from the branch.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-11 08:41:49 -07:00

825 lines
26 KiB
TypeScript
Generated

// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { FilterHistoryEntry, Flow, FlowBody, FlowMessage, GrpcSchema, ModelPayload, SavedQuery, TunnelReason } from "./gen_models";
export type ActionInvocation = { "scope": "global", action: GlobalAction, };
export type ActionMetadata = { label: string, defaultHotkey: string | null, };
export type AddGrpcSchemaRequest = {
/**
* `api.example.com`, `localhost:50051`, `*.example.com` or `*`.
*/
hostPattern: string,
/**
* `.proto` files, and directories they import from.
*/
protoPaths: Array<string>, };
export type AppIconRequest = {
/**
* A flow's `clientPath`.
*/
path: string, };
export type CaStatus = {
/**
* macOS trusts this app's CA, so HTTPS flows can be decrypted.
*/
trusted: boolean,
/**
* A certificate named "Yaak Proxy CA" is in a keychain: this one, or an older one.
*/
installed: boolean, certPath: string, };
export type CaStatusRequest = Record<string, never>;
export type CaTrustRequest = Record<string, never>;
/**
* What came of asking to trust the CA, with its status after.
*/
export type CaTrustResult = {
/**
* The person cancelled the password prompt, so nothing changed. Not an error.
*/
cancelled: boolean,
/**
* macOS trusts this app's CA, so HTTPS flows can be decrypted.
*/
trusted: boolean,
/**
* A certificate named "Yaak Proxy CA" is in a keychain: this one, or an older one.
*/
installed: boolean, certPath: string, };
export type ClearFilterHistoryRequest = Record<string, never>;
export type ClearFlowsRequest = Record<string, never>;
/**
* The app behind a client connection.
*/
export type ClientApp = { pid: number,
/**
* The app's name ("Google Chrome"), or the executable's for a process outside an app ("curl").
*/
name: string,
/**
* The outermost `.app` bundle's CFBundleIdentifier, if any.
*/
bundleId: string | null,
/**
* The outermost `.app` bundle's path, or the executable's path when there is no bundle.
*/
path: string,
/**
* The working directory of a process outside an app, as it was when first looked up.
*/
cwd: string | null, };
export type CountSavedQueriesRequest = { hideSystem?: boolean, hideEncrypted?: boolean, };
export type CreateSavedQueryRequest = { name: string, query: string, };
export type DecodeGrpcMessageRequest = { flowId: string, seq: number,
/**
* Decode without a schema even when one is found.
*/
schemaless?: boolean, };
/**
* A captured gRPC message as JSON.
*/
export type DecodedGrpcMessage = {
/**
* Pretty JSON: the message's fields by name with a schema; without one, an array of its
* fields as `{ field, wireType, value }`, a length-delimited one with its guesses (`string`,
* `message`, `bytes` in base64).
*/
json: string,
/**
* The message type decoded with: `package.HelloReply`. None when schemaless.
*/
messageType: string | null,
/**
* The schema decoded with. None when schemaless.
*/
schema: GrpcSchema | null,
/**
* Why it decoded schemaless, or what to know about the decode.
*/
note: string | null, };
/**
* What HTTPS is decrypted: the user's entries in order, then the built-in exclusions not
* removed. A connection is decrypted when a positive entry matches it and no exclusion does.
*/
export type DecryptList = { entries: Array<DecryptListEntry>, };
/**
* The decrypt list changed, here or through the control API.
*/
export type DecryptListChangedPayload = { list: DecryptList, };
/**
* One entry of the decrypt list, as the app shows it.
*/
export type DecryptListEntry = {
/**
* As stored: `host:*.example.com`, `app:Google Chrome`, `!host:*.apple.com`, `*`.
*/
entry: string,
/**
* Shipped with the app: an exclusion of Apple's services or a pinned app's hosts.
*/
builtIn: boolean,
/**
* Why a built-in exclusion ships. None for the user's own entries.
*/
kind?: ExclusionKind, };
/**
* The decrypt list as saved, and what it means for connections already open.
*/
export type DecryptListSaved = {
/**
* Open connections the list now decrypts that stay encrypted until their clients
* reconnect: `reconnect_tunnels` closes them so they do. Closed by nothing else. Zero from
* an owner too old to count them.
*/
stillEncrypted: number, entries: Array<DecryptListEntry>, };
export type DeleteFilterHistoryRequest = { filter: string, };
export type DeleteSavedQueryRequest = { id: string, };
export type DropReason = "hop_by_hop" | "set_by_sending" | "body_decoded";
export type DroppedHeader = { name: string, value: string, reason: DropReason, };
/**
* Entries to add after the user's own and to remove, applied to the list as it is when the
* change lands. Each is normalized first.
*/
export type EditDecryptListRequest = { add: Array<string>, remove: Array<string>, };
/**
* Why a built-in exclusion ships.
*/
export type ExclusionKind = "apple" | "pinned";
export type ExportHarRequest = {
/**
* The file to write.
*/
path: string,
/**
* These flows, or else every flow the filter covers.
*/
ids?: Array<string>, filter?: FlowFilter, };
export type FilterBodyRequest = { flowId: string, which: FlowBody,
/**
* JSONPath, or XPath for an XML or HTML body.
*/
expression: string,
/**
* The language the viewer detected from the body. Without it, the Content-Type decides.
*/
language?: FilterLanguage, };
export type FilterBodyResponse = { content: string, error: string | null, };
export type FilterHistoryChangedPayload = Record<string, never>;
export type FilterLanguage = "jsonpath" | "xpath";
/**
* Which flows a listing or a HAR export covers: a search, and a page of it.
*/
export type FlowFilter = {
/**
* A search in the query language (`crate::query`): `stripe @status:4xx`,
* `@host:*.github.com -@is:system`. None or blank covers every flow.
*/
query?: string,
/**
* Leaves out macOS's own daemons, as hiding System does, unless the query says
* `@is:system` itself.
*/
hideSystem?: boolean,
/**
* Leaves out HTTPS connections passed through undecrypted, as hiding Encrypted does,
* unless the query says `@is:encrypted` itself.
*/
hideEncrypted?: boolean,
/**
* At most this many flows, the newest.
*/
limit?: number,
/**
* Only flows recorded after the flow with this id, for following new traffic. Flows are
* recorded when they end, so a slow one that started earlier still comes through.
*/
after?: string,
/**
* Only flows older than the flow with this id, by start and then id, for paging back
* through older traffic.
*/
before?: string,
/**
* The order to list in, the list's column sort: each key in turn, then by start and id,
* oldest first. Empty lists newest first, as without it. With keys, `before` does not
* apply; `cursor` pages instead.
*/
sort?: Array<FlowSortKey>,
/**
* Only flows after these values in `sort`'s order, for paging through a sort: the `cursor`
* of the page before, the sort values of its last flow as it was read, so a change to that
* flow since does not move where the next page starts.
*/
cursor?: Array<SortValue>, };
/**
* One key of a sort.
*/
export type FlowSortKey = { column: SortColumn | `field:${string}`, descending: boolean, };
export type FlowsClearedPayload = Record<string, never>;
/**
* Flows deleted to keep captured traffic under the keep-traffic cap, the oldest first.
*/
export type FlowsRemovedPayload = { ids: Array<string>, };
export type FolderSummary = { id: string, name: string,
/**
* The folder this one is in, if any.
*/
folderId: string | null, };
/**
* An address to intercept again: `host`, `host:port` or `[::1]:8443`, as a flow's URL has
* it, the port 443 when left out.
*/
export type ForgetPassthroughRequest = { address: string, };
export type ForgetPassthroughResponse = {
/**
* It was passed through.
*/
forgotten: boolean,
/**
* The addresses still passed through.
*/
addresses: Array<string>, };
export type FormatBodyRequest = { text: string, };
export type GetDecryptListRequest = Record<string, never>;
export type GetFlowBodyRequest = { flowId: string, which: FlowBody, };
export type GetFlowBodyResponse = {
/**
* The body decoded with its Content-Encoding, at most the capture limit of it, in base64.
* When it fails to decode, the bytes as they were on the wire instead.
*/
data: string,
/**
* The body is incomplete: cut on the wire, or decoded past the capture limit.
*/
truncated: boolean,
/**
* Bytes stored for the body, as they were on the wire.
*/
storedSize: number,
/**
* Why the body failed to decode, in which case `data` is as it was on the wire.
*/
decodeError?: string,
/**
* What to know about the body beyond its bytes, as that a WebSocket has none.
*/
note?: string, };
/**
* Flows by id, for showing ones the list has not loaded. Those cleared or deleted are left out.
*/
export type GetFlowsRequest = { ids: Array<string>, };
export type GetLastFilterRequest = Record<string, never>;
export type GetMessagePayloadRequest = { flowId: string, seq: number, };
export type GetMessagePayloadResponse = {
/**
* The payload as stored (unmasked, inflated, decompressed), in base64.
*/
data: string,
/**
* It is cut at the capture limit.
*/
truncated: boolean, };
export type GetProxyStateRequest = Record<string, never>;
export type GetProxyStateResponse = { state: ProxyState,
/**
* The port the engine is bound to, while it runs.
*/
port: number | null,
/**
* The port the engine starts on.
*/
configuredPort: number,
/**
* Flows are stored. Paused, traffic still passes through, unrecorded.
*/
recording: boolean,
/**
* The system proxy turns on as the engine starts.
*/
systemProxyAtLaunch: boolean,
/**
* The HTTP versions offered to clients.
*/
httpVersion: HttpVersion,
/**
* Bytes of each body stored per flow.
*/
captureBodyLimit: number,
/**
* Captured traffic is cleared at launch or kept between launches.
*/
traffic: TrafficRetention,
/**
* The most captured traffic kept, in bytes, or null to keep everything. Applies only
* while traffic is kept.
*/
keepTrafficBytes: number | null,
/**
* Why the engine last failed to start, until it starts.
*/
startError: string | null,
/**
* How far encrypting traffic stored before encryption has got, from 0 to 1, while it
* runs. The engine starts once it is done.
*/
encrypting: number | null,
/**
* Captured traffic cannot be read: its key is unavailable, or it is being encrypted.
*/
locked: ProxyLock | null,
/**
* Another process that owns the engine, such as the CLI daemon. While one does, this app
* cannot start its own, and new flows reach it only through the database.
*/
otherOwner: OtherOwner | null, };
export type GetStorageSizeRequest = Record<string, never>;
export type GetStorageSizeResponse = {
/**
* The databases' used pages, as the keep-traffic cap counts them; locked, their files'
* sizes on disk.
*/
bytes: number, };
export type GetWindowPlacesRequest = Record<string, never>;
export type GlobalAction = "recording_toggle" | "flows_clear";
export type HelperRegisterRequest = Record<string, never>;
export type HelperState = "unavailable" | "not_registered" | "requires_approval" | "enabled" | "not_found";
export type HelperUnregisterRequest = Record<string, never>;
/**
* The HTTP versions offered to clients in intercepted HTTPS. Upstream, the engine speaks
* whichever the server picks either way.
*/
export type HttpVersion = "auto" | "http1Only";
export type ListActionsRequest = Record<string, never>;
export type ListActionsResponse = { actions: Array<[ActionInvocation, ActionMetadata]>, };
export type ListFilterHistoryRequest = Record<string, never>;
export type ListFlowsResponse = {
/**
* Newest first.
*/
flows: Array<Flow>,
/**
* Flows in the database, whatever the filter.
*/
total: number,
/**
* Flows the filter covers, whatever the limit, when it narrows to fewer than all of them.
*/
matching: number | null,
/**
* Sorted, the next page's `cursor`: the last flow's sort values, as read. None without a
* sort or a flow.
*/
cursor: Array<SortValue> | null, };
export type ListGrpcSchemasRequest = Record<string, never>;
export type ListMessagesRequest = { flowId: string,
/**
* Only messages after this `seq`, for following a stream as it grows.
*/
afterSeq?: number,
/**
* At most this many, the first after `afterSeq`.
*/
limit?: number, };
export type ListMessagesResponse = {
/**
* In order, by `seq`.
*/
messages: Array<FlowMessage>,
/**
* Messages the flow has in all.
*/
total: number, };
export type ListPassthroughRequest = Record<string, never>;
export type ListSavedQueriesRequest = Record<string, never>;
export type ListSeenRequest = Record<string, never>;
export type ListWorkspacesRequest = Record<string, never>;
export type ListWorkspacesResponse = {
/**
* Yaak has run on this machine. Without it there is nothing to save into.
*/
yaakFound: boolean, workspaces: Array<WorkspaceSummary>, };
/**
* Which of some flows a search covers, for flows whose events were matched against another.
*/
export type MatchFlowsRequest = { filter: FlowFilter, ids: Array<string>, };
/**
* A message of a streaming flow was recorded.
*/
export type MessagePayload = { message: FlowMessage, };
export type OpenTerminalRequest = {
/**
* Environment variables the shell starts with, by name: `HTTPS_PROXY`.
*/
vars: Array<[string, string]>, };
/**
* An open tunnel, as the app is told of it.
*/
export type OpenTunnel = {
/**
* Its id for closing it, unique to this run of the engine, so one listed before the
* engine restarted closes nothing after.
*/
id: string,
/**
* The host it leads to, without an IPv6 address's brackets.
*/
host: string, port: number,
/**
* The app that opened it, when known.
*/
appName: string | null, appBundleId: string | null,
/**
* Its flow, when it was recorded.
*/
flowId: string | null, reason: TunnelReason, };
export type OtherOwner = { owner: Owner, pid: number, startedAt: string,
/**
* The engine's port while it runs.
*/
proxyPort: number | null, };
/**
* The process that runs the engine.
*/
export type Owner = "app" | "cli";
/**
* The addresses passed through after clients rejected the CA changed: one was added or
* forgotten.
*/
export type PassthroughChangedPayload = {
/**
* Each `host:port`, an IPv6 host in brackets, sorted.
*/
addresses: Array<string>, };
/**
* The addresses passed through after clients rejected the CA.
*/
export type PassthroughResponse = {
/**
* Each `host:port`, an IPv6 host in brackets, sorted.
*/
addresses: Array<string>, };
export type PreviewSaveRequest = { flowId: string, };
/**
* Why captured traffic cannot be read, for the window's locked state.
*/
export type ProxyLock = {
/**
* What every refused read says.
*/
message: string,
/**
* The keychain would not give up the key, or has not been asked yet, so allowing Yaak
* Proxy in Keychain Access is the way out.
*/
keychain: boolean, };
export type ProxySetting = { enabled: boolean, server: string, port: number, };
export type ProxyState = "running" | "stopped";
export type ProxyStatePayload = { state: ProxyState, };
/**
* A term the query cannot run, which then matches nothing. `start` and `end` count UTF-16
* code units, as JavaScript does.
*/
export type QueryDiagnostic = { kind: QueryDiagnosticKind, path: string, start: number, end: number, };
/**
* What is wrong with a term, for the search box to mark.
*/
export type QueryDiagnosticKind = "unknownField" | "invalidValue" | "notYet";
export type QuerySchemaRequest = Record<string, never>;
/**
* The search's fields, for the search box's highlighting and completion.
*/
export type QuerySchemaResponse = { schema: import("@yaakapp-internal/query").Schema, };
export type QueryValuesRequest = {
/**
* A field's path: `host`, `header` for header names, `header.accept` for a header's values.
*/
path: string, };
/**
* Tunnels to close: those in `ids`, or, without them, every one `list_reconnectable_tunnels`
* returns for the same `entry` and `flowId`.
*/
export type ReconnectTunnelsRequest = {
/**
* `OpenTunnel` ids. Ones from an earlier run of the engine close nothing.
*/
ids?: Array<string>,
/**
* An entry as stored or typed, `host:www.google.com`, `app:Dia`, `*`: only tunnels it
* names. An exclusion, `!host:*.chase.com`, names those it would keep out.
*/
entry?: string,
/**
* Only the tunnel this flow records.
*/
flowId?: string, };
export type ReconnectTunnelsResponse = {
/**
* Tunnels closed: those still open of the ones asked for.
*/
closed: number, };
/**
* A filter applied from the search box, or from the history itself, put at its top.
*/
export type RecordFilterRequest = { filter: string, };
export type ReflectGrpcHostRequest = {
/**
* `host` or `host:port`, over TLS on 443 unless a port is given, or either after
* `http://` to ask without TLS.
*/
host: string, };
export type RemoveGrpcSchemaRequest = { id: string, };
export type RenameSavedQueryRequest = { id: string, name: string, };
export type ResetCapturedDataRequest = Record<string, never>;
export type RpcEventSchema = { decrypt_list_changed: DecryptListChangedPayload, filter_history_changed: FilterHistoryChangedPayload, flows_cleared: FlowsClearedPayload, flows_removed: FlowsRemovedPayload, message_write: MessagePayload, model_write: ModelPayload, passthrough_changed: PassthroughChangedPayload, proxy_state_changed: ProxyStatePayload, saved_queries_changed: SavedQueriesChangedPayload, };
export type RpcSchema = { execute_action: [ActionInvocation, boolean], format_body: [FormatBodyRequest, string], get_decrypt_list: [GetDecryptListRequest, DecryptList], get_message_payload: [GetMessagePayloadRequest, GetMessagePayloadResponse], list_actions: [ListActionsRequest, ListActionsResponse], list_flows: [FlowFilter, ListFlowsResponse], query_schema: [QuerySchemaRequest, QuerySchemaResponse], validate_query: [ValidateQueryRequest, Array<QueryDiagnostic>], watch_query: [WatchQueryRequest, boolean], list_saved_queries: [ListSavedQueriesRequest, Array<SavedQuery>], create_saved_query: [CreateSavedQueryRequest, SavedQuery], rename_saved_query: [RenameSavedQueryRequest, SavedQuery], delete_saved_query: [DeleteSavedQueryRequest, boolean], list_filter_history: [ListFilterHistoryRequest, Array<FilterHistoryEntry>], record_filter: [RecordFilterRequest, boolean], delete_filter_history: [DeleteFilterHistoryRequest, boolean], clear_filter_history: [ClearFilterHistoryRequest, number], get_last_filter: [GetLastFilterRequest, string], set_last_filter: [SetLastFilterRequest, boolean], get_window_places: [GetWindowPlacesRequest, string | null], set_window_places: [SetWindowPlacesRequest, boolean], list_grpc_schemas: [ListGrpcSchemasRequest, Array<GrpcSchema>], list_messages: [ListMessagesRequest, ListMessagesResponse], remove_grpc_schema: [RemoveGrpcSchemaRequest, boolean], set_recording: [SetRecordingRequest, boolean], set_system_proxy_at_launch: [SetSystemProxyAtLaunchRequest, boolean], set_http_version: [SetHttpVersionRequest, HttpVersion], set_capture_body_limit: [SetCaptureBodyLimitRequest, number], set_traffic: [SetTrafficRequest, TrafficRetention], set_keep_traffic: [SetKeepTrafficRequest, number | null], add_grpc_schema: [AddGrpcSchemaRequest, GrpcSchema], app_icon: [AppIconRequest, string | null], ca_status: [CaStatusRequest, CaStatus], ca_trust: [CaTrustRequest, CaTrustResult], forget_passthrough: [ForgetPassthroughRequest, ForgetPassthroughResponse], list_passthrough: [ListPassthroughRequest, PassthroughResponse], list_reconnectable_tunnels: [TunnelScope, Array<OpenTunnel>], reconnect_tunnels: [ReconnectTunnelsRequest, ReconnectTunnelsResponse], clear_flows: [ClearFlowsRequest, number], decode_grpc_message: [DecodeGrpcMessageRequest, DecodedGrpcMessage], export_har: [ExportHarRequest, number], filter_body: [FilterBodyRequest, FilterBodyResponse], get_flow_body: [GetFlowBodyRequest, GetFlowBodyResponse], get_proxy_state: [GetProxyStateRequest, GetProxyStateResponse], helper_register: [HelperRegisterRequest, SystemProxyStatus], helper_unregister: [HelperUnregisterRequest, SystemProxyStatus], edit_decrypt_list: [EditDecryptListRequest, DecryptListSaved], list_seen: [ListSeenRequest, SeenTargets], set_decrypt_list: [SetDecryptListRequest, DecryptListSaved], list_workspaces: [ListWorkspacesRequest, ListWorkspacesResponse], preview_save: [PreviewSaveRequest, SavePreview], reflect_grpc_host: [ReflectGrpcHostRequest, GrpcSchema], save_flow: [SaveFlowToYaakRequest, SavedFlow], save_flow_body: [SaveFlowBodyRequest, SaveFlowBodyResponse], system_proxy_set: [SystemProxySetRequest, SystemProxyStatus], system_proxy_status: [SystemProxyStatusRequest, SystemProxyStatus], take_over: [TakeOverRequest, boolean], set_port: [SetPortRequest, number], get_storage_size: [GetStorageSizeRequest, GetStorageSizeResponse], reset_captured_data: [ResetCapturedDataRequest, boolean], open_terminal: [OpenTerminalRequest, boolean], query_values: [QueryValuesRequest, Array<string>], match_flows: [MatchFlowsRequest, Array<string>], get_flows: [GetFlowsRequest, Array<Flow>], count_saved_queries: [CountSavedQueriesRequest, Array<SavedQueryCount>], };
export type SaveFlowBodyRequest = { flowId: string, which: FlowBody,
/**
* The file to write.
*/
path: string, };
export type SaveFlowBodyResponse = {
/**
* Bytes written.
*/
size: number,
/**
* What was written is incomplete, as `GetFlowBodyResponse.truncated` is.
*/
truncated: boolean,
/**
* The body failed to decode, so the file has it as it was on the wire.
*/
raw: boolean, };
export type SaveFlowToYaakRequest = { flowId: string, workspaceId: string, folderId?: string,
/**
* None or blank leaves the request unnamed, and Yaak shows its URL.
*/
name?: string, };
/**
* What saving a flow as a Yaak request writes, for the save dialog.
*/
export type SavePreview = { method: string, url: string,
/**
* The URL as saved, its query split out into parameters, which Yaak shows for an unnamed
* request.
*/
requestUrl: string,
/**
* The saved body type, which Yaak shows for an unnamed GraphQL request with no URL.
*/
bodyType: string | null,
/**
* Headers Yaak sets itself or that only meant something to the proxy.
*/
droppedHeaders: Array<DroppedHeader>,
/**
* Headers saved as captured, Authorization among them.
*/
keptHeaders: number,
/**
* The body as it is saved: "JSON", "a URL-encoded form with 7 fields". None without a body.
*/
body: string | null,
/**
* What does not carry over exactly, one sentence each.
*/
warnings: Array<string>,
/**
* An Authorization header is saved in plain text.
*/
authorization: boolean, };
export type SavedFlow = { requestId: string, name: string, };
export type SavedQueriesChangedPayload = Record<string, never>;
/**
* How many flows a saved query covers.
*/
export type SavedQueryCount = { id: string, count: number, };
export type SeenApp = { name: string, bundleId: string | null, };
/**
* The hosts and apps flows have gone to and come from, for the decrypt list's suggestions.
*/
export type SeenTargets = {
/**
* Hosts as the sidebar names them, with a port other than the scheme's: most recent first.
*/
hosts: Array<string>,
/**
* Apps by name and bundle id, most recent first.
*/
apps: Array<SeenApp>, };
export type ServiceProxy = {
/**
* The network service, as System Settings names it: "Wi-Fi", "USB 10/100/1000 LAN".
*/
name: string,
/**
* What stays the same when the service is renamed: its device ("en0"), or its hardware
* port when it has none. Absent when `networksetup` lists neither.
*/
id?: string, http: ProxySetting, https: ProxySetting, };
export type SetCaptureBodyLimitRequest = { bytes: number, };
export type SetDecryptListRequest = {
/**
* Every entry, in order, as typed: a bare hostname is a `host:` entry. A built-in
* exclusion left out is removed.
*/
entries: Array<string>, };
export type SetHttpVersionRequest = { httpVersion: HttpVersion, };
export type SetKeepTrafficRequest = {
/**
* Null keeps everything.
*/
bytes: number | null, };
/**
* The filter the window applied, kept in the encrypted database for the next launch.
*/
export type SetLastFilterRequest = { filter: string, };
export type SetPortRequest = { port: number, };
export type SetRecordingRequest = { enabled: boolean, };
export type SetSystemProxyAtLaunchRequest = { enabled: boolean, };
export type SetTrafficRequest = { traffic: TrafficRetention, };
/**
* The window's places, opaque to the engine, kept in memory for a reload of the window.
*/
export type SetWindowPlacesRequest = { places: string, };
/**
* A column the list sorts by.
*/
export type SortColumn = "number" | "app" | "method" | "host" | "path" | "query" | "status" | "type" | "size" | "requestSize" | "time" | "latency" | "started" | "remote" | "version" | "tls" | "operation";
/**
* One of a flow's sort values, as the database sorted it.
*/
export type SortValue = number | string;
/**
* How a change gets administrator rights.
*/
export type SystemProxyBackend = "helper" | "admin_prompt" | "sudo";
export type SystemProxySetRequest = { enabled: boolean, };
export type SystemProxyStatus = {
/**
* Every enabled network service sends HTTP and HTTPS to `127.0.0.1:<port>`.
*/
enabled: boolean,
/**
* The port checked against.
*/
port: number, services: Array<ServiceProxy>, backend: SystemProxyBackend,
/**
* The privileged helper's registration, which decides the backend.
*/
helper: HelperState,
/**
* This platform has a system proxy the app can set.
*/
supported: boolean, };
export type SystemProxyStatusRequest = Record<string, never>;
export type TakeOverRequest = Record<string, never>;
/**
* What happens to captured traffic between launches.
*/
export type TrafficRetention = "clearOnLaunch" | "keep";
/**
* Which open tunnels to consider: all of them, those one decrypt-list entry names, or the one
* a flow records.
*/
export type TunnelScope = {
/**
* An entry as stored or typed, `host:www.google.com`, `app:Dia`, `*`: only tunnels it
* names. An exclusion, `!host:*.chase.com`, names those it would keep out.
*/
entry?: string,
/**
* Only the tunnel this flow records.
*/
flowId?: string, };
export type ValidateQueryRequest = { query: string, };
/**
* The search the app shows, which flows written from now on are matched against, their events
* naming `key`. No query stops it.
*/
export type WatchQueryRequest = { key: string, query?: string, hideSystem?: boolean, hideEncrypted?: boolean, };
export type WorkspaceSummary = { id: string, name: string, folders: Array<FolderSummary>, };