greentic-interfaces 0.4.113

Greentic ABI: WIT contracts, generated bindings, thin mappers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

// SPDX-License-Identifier: MIT

package greentic:interfaces-types@0.1.0;

interface types {
  /// Environment identifier.
  type env-id = string;

  /// Tenant identifier propagated across providers.
  type tenant-id = string;

  /// Team identifier scoped to a tenant.
  type team-id = string;

  /// User identifier scoped to a tenant.
  type user-id = string;

  /// Stable key referencing persisted state blobs.
  type state-key = string;

  /// Stable key referencing sessions.
  type session-key = string;

  /// Impersonation context propagated with a tenant.
  record impersonation {
    actor-id: user-id,
    reason: option<string>,
  }

  /// Invocation tenant context shared across Greentic surfaces.
  record tenant-ctx {
    env: env-id,
    tenant: tenant-id,
    tenant-id: tenant-id,
    team: option<team-id>,
    team-id: option<team-id>,
    user: option<user-id>,
    user-id: option<user-id>,
    trace-id: option<string>,
    i18n-id: option<string>,
    correlation-id: option<string>,
    attributes: list<tuple<string, string>>,
    session-id: option<string>,
    flow-id: option<string>,
    node-id: option<string>,
    provider-id: option<string>,
    deadline-ms: option<s64>,
    attempt: u32,
    idempotency-key: option<string>,
    impersonation: option<impersonation>,
  }

  /// Cursor describing a session position.
  record session-cursor {
    node-pointer: string,
    wait-reason: option<string>,
    outbox-marker: option<string>,
  }

  /// Canonical error codes surfaced by the platform.
  enum error-code {
    unknown,
    invalid-input,
    not-found,
    conflict,
    timeout,
    unauthenticated,
    permission-denied,
    rate-limited,
    unavailable,
    internal,
  }

  /// Canonical host error payload.
  record host-error {
    code: string,
    message: string,
  }

  /// Standard error codes returned by host services.
  enum iface-error {
    invalid-arg,
    not-found,
    denied,
    unavailable,
    internal,
  }

  /// Pending outcome payload.
  record outcome-pending {
    reason: string,
    expected-input: option<list<string>>,
  }

  /// Error outcome payload.
  record outcome-error {
    code: error-code,
    message: string,
  }

  /// Execution outcome for string payloads.
  variant outcome {
    done(string),
    pending(outcome-pending),
    error(outcome-error),
  }

  /// Supported network protocols.
  variant protocol {
    http,
    https,
    tcp,
    udp,
    grpc,
    custom(string),
  }

  /// Allow list describing permitted connectivity.
  record allow-list {
    domains: list<string>,
    ports: list<u16>,
    protocols: list<protocol>,
  }

  /// Network policy composed of allow lists.
  record network-policy {
    egress: allow-list,
    deny-on-miss: bool,
  }

  /// Detached signature accompanying a pack.
  variant signature-algorithm {
    ed25519,
    other(string),
  }

  record signature {
    key-id: string,
    algorithm: signature-algorithm,
    signature: list<u8>,
  }

  /// Pack reference stored in registries.
  record pack-ref {
    oci-url: string,
    version: string,
    digest: string,
    signatures: list<signature>,
  }

  /// Minimal telemetry span context.
  record span-context {
    tenant: tenant-id,
    session-id: option<session-key>,
    flow-id: string,
    node-id: option<string>,
    provider: string,
    start-ms: option<s64>,
    end-ms: option<s64>,
  }
}