Skip to content
Kindgi

Models: M

View as Markdown

MCPAuthHeader

Section titled “MCPAuthHeader”

One header a header auth sends: <name>: <prefix><secret>.

  • name: str
  • secret_ref: kindgi.client.MCPEndpointSecretRef (secretRef on the wire)
  • prefix: str | None (optional)

MCPBasicAuth

Section titled “MCPBasicAuth”

HTTP Basic: the runtime sends Authorization: Basic base64(<username>:<secret>), with the secret secretRef names (a WordPress Application Password, for one).

  • scheme: Literal['basic']
  • username: str
  • secret_ref: kindgi.client.MCPEndpointSecretRef (secretRef on the wire)

MCPEndpoint

Section titled “MCPEndpoint”
  • endpoint_id: str (endpointId on the wire)
  • name: str
  • transport: Union[Literal['stdio', 'http-sse', 'streamable-http'], str]
  • config: kindgi.client.MCPEndpointConfigStdio | kindgi.client.MCPEndpointConfigHttpSse | kindgi.client.MCPEndpointConfigStreamableHttp | kindgi.client.MCPEndpointConfigUnrecognized
  • secret_ref: kindgi.client.MCPEndpointSecretRef | None (secretRef on the wire) (optional)
  • auth: Optional[Annotated[kindgi.client.MCPBasicAuth | kindgi.client.MCPOAuth2ClientCredentialsAuth | kindgi.client.MCPHeaderAuth | kindgi.client.MCPEndpointAuthUnrecognized, <kindgi.client._open.OpenUnion object at 0x10a55c2d0>]] (optional)
  • instructions: str | None (optional)
  • metadata: dict[str, Any] | None (optional)
  • send_traceparent: bool | None (sendTraceparent on the wire) (optional)
  • secret_scopes: dict[str, Optional[Annotated[kindgi.client.RecordedSecretScopeTenant | kindgi.client.RecordedSecretScopeOrg | kindgi.client.RecordedSecretScopeProject | kindgi.client.RecordedSecretScopeUnrecognized, <kindgi.client._open.OpenUnion object at 0x10a55c610>]]] | None (secretScopes on the wire) (optional)

MCPEndpointAuthUnrecognized

Section titled “MCPEndpointAuthUnrecognized”

A scheme this client doesn't know yet, from a newer runtime: the object as it came, every field kept.

  • scheme: str

MCPEndpointCollectionPage

Section titled “MCPEndpointCollectionPage”
  • data: list[kindgi.client.MCPEndpoint]
  • next_cursor: str | None (nextCursor on the wire) (optional)
  • has_more: bool (hasMore on the wire)

MCPEndpointConfigHttpSse

Section titled “MCPEndpointConfigHttpSse”

Transport-tagged config union. Server enforces config.transport === transport at registration.

  • transport: Literal['http-sse']
  • url: AnyUrl
  • sse_url: AnyUrl | None (sseUrl on the wire) (optional)
  • headers: dict[str, str] | None (optional)

MCPEndpointConfigStdio

Section titled “MCPEndpointConfigStdio”

Transport-tagged config union. Server enforces config.transport === transport at registration.

  • transport: Literal['stdio']
  • command: str
  • args: list[str] | None (optional)
  • env: dict[str, str] | None (optional)

MCPEndpointConfigStreamableHttp

Section titled “MCPEndpointConfigStreamableHttp”

Transport-tagged config union. Server enforces config.transport === transport at registration.

  • transport: Literal['streamable-http']
  • url: AnyUrl
  • headers: dict[str, str] | None (optional)

MCPEndpointConfigUnrecognized

Section titled “MCPEndpointConfigUnrecognized”

A transport this client doesn't know yet, from a newer runtime: the object as it came, every field kept.

  • transport: str

MCPEndpointSecretRef

Section titled “MCPEndpointSecretRef”

The secret an MCP endpoint authenticates with: a name in the deployment's secrets store, resolved at the endpoint's tenant scope by the runtime (the shape webhooks and providers use). As the endpoint's own secretRef, it is sent as its bearer; inside auth, it is the scheme's password, client secret or header value. The endpoint keeps only this reference.

  • env_name: str (envName on the wire)
  • name: str

MCPHeaderAuth

Section titled “MCPHeaderAuth”

Headers of the server's own, each with a secret: an API key in X-Api-Key, a key and a secret in two headers, or Authorization with a prefix other than Bearer (Token …). The runtime resolves each secretRef when it connects, and refuses to follow a redirect with them, as it does for every auth.

  • scheme: Literal['header']
  • headers: list[kindgi.client.MCPAuthHeader]

MCPOAuth2ClientCredentialsAuth

Section titled “MCPOAuth2ClientCredentialsAuth”

OAuth 2 client credentials: the runtime asks tokenUrl for an access token (grant_type=client_credentials) as clientId, with the client secret secretRef names, sends it as the endpoint's bearer, and asks for a new one before it expires (Drupal's Simple OAuth, for one). The token is never stored.

  • scheme: Literal['oauth2-client-credentials']
  • token_url: AnyUrl (tokenUrl on the wire)
  • client_id: str (clientId on the wire)
  • secret_ref: kindgi.client.MCPEndpointSecretRef (secretRef on the wire)
  • scope: str | None (optional)
  • audience: str | None (optional)
  • client_auth: Optional[Annotated[Union[Literal['client_secret_basic', 'client_secret_post'], str], <kindgi.client._open.OpenEnum object at 0x10980e890>]] (clientAuth on the wire) (optional)

MCPPrompt

Section titled “MCPPrompt”
  • name: str
  • description: str | None (optional)
  • arguments: list[kindgi.client.MCPPromptArgument] | None (optional)

MCPPromptArgument

Section titled “MCPPromptArgument”
  • name: str
  • description: str | None (optional)
  • required: bool | None (optional)

MCPPromptCollection

Section titled “MCPPromptCollection”
  • data: list[kindgi.client.MCPPrompt]

MCPPromptMessage

Section titled “MCPPromptMessage”
  • role: Union[Literal['user', 'assistant'], str]
  • content: kindgi.client.MCPPromptMessageContentText | kindgi.client.MCPPromptMessageContentImage | kindgi.client.MCPPromptMessageContentUnrecognized

MCPPromptMessageContentImage

Section titled “MCPPromptMessageContentImage”
  • type: Literal['image']
  • data: str
  • mime_type: str (mimeType on the wire)

MCPPromptMessageContentText

Section titled “MCPPromptMessageContentText”
  • type: Literal['text']
  • text: str

MCPPromptMessageContentUnrecognized

Section titled “MCPPromptMessageContentUnrecognized”

A type this client doesn't know yet, from a newer runtime: the object as it came, every field kept.

  • type: str

MCPResource

Section titled “MCPResource”
  • uri: str
  • name: str
  • description: str | None (optional)
  • mime_type: str | None (mimeType on the wire) (optional)

MCPResourceCollection

Section titled “MCPResourceCollection”
  • data: list[kindgi.client.MCPResource]

MCPResourceContent

Section titled “MCPResourceContent”
  • uri: str
  • mime_type: str | None (mimeType on the wire) (optional)
  • text: str | None (optional)
  • blob: str | None (optional)

MailFire

Section titled “MailFire”

One mail a mail trigger found and what came of it. A thread's mail runs one at a time, oldest first.

  • fire_id: str (fireId on the wire)
  • trigger_id: str (triggerId on the wire)
  • fired_at: AwareDatetime (firedAt on the wire)
  • outcome: Union[Literal['pending', 'started', 'skipped', 'refused', 'failed'], str]
  • run_id: uuid.UUID | None (runId on the wire) (optional)
  • version: int | None (optional)
  • detail: str | None (optional)
  • counts_toward_pause: bool | None (countsTowardPause on the wire) (optional)

MailFirePage

Section titled “MailFirePage”
  • data: list[kindgi.client.MailFire]
  • has_more: bool (hasMore on the wire)
  • next_cursor: str | None (nextCursor on the wire) (optional)

MailTriggerCollectionPage

Section titled “MailTriggerCollectionPage”
  • data: list[kindgi.client.MailTriggerRecord]
  • next_cursor: str | None (nextCursor on the wire) (optional)
  • has_more: bool (hasMore on the wire)

MailTriggerDefinition

Section titled “MailTriggerDefinition”

What a mail trigger's version runs, as whom, and which mailbox it reads at what pace, as its record names them, and never its state (status, next or last fire).

  • flow_id: str | None (flowId on the wire) (optional)
  • flow_version: str | None (flowVersion on the wire) (optional)
  • agent_id: str | None (agentId on the wire) (optional)
  • agent_version: str | None (agentVersion on the wire) (optional)
  • project_id: uuid.UUID (projectId on the wire)
  • owner: kindgi.client.TriggerOwner
  • mailbox: kindgi.client.MailTriggerMailbox
  • folder: str | None (optional)
  • poll_seconds: int (pollSeconds on the wire)
  • runs_per_hour: int (runsPerHour on the wire)
  • label: str | None
  • tools_allowed_unattended: list[kindgi.client.ToolsAllowedUnattendedItem] | None (toolsAllowedUnattended on the wire) (optional)

MailTriggerMailbox

Section titled “MailTriggerMailbox”

The mailbox a mail trigger reads: its app (google: Gmail; microsoft: Outlook) and whose it is (company: the company's mailbox, through the company's connection of that app; person: the trigger owner's own, through their connection).

  • app: Union[Literal['google', 'microsoft'], str]
  • as_: Union[Literal['person', 'company'], str] (as on the wire)

MailTriggerRecord

Section titled “MailTriggerRecord”

A mail trigger: each new mail in its mailbox's folder starts a run of its agent or flow, with the mail as the run's input, as its owner. In such a run, every call that changes something, or uses the run's own mailbox, waits for a person's yes unless the trigger lists it (toolsAllowedUnattended).

  • trigger_id: str (triggerId on the wire)
  • flow_id: str | None (flowId on the wire) (optional)
  • flow_version: str | None (flowVersion on the wire) (optional)
  • agent_id: str | None (agentId on the wire) (optional)
  • agent_version: str | None (agentVersion on the wire) (optional)
  • project_id: uuid.UUID (projectId on the wire)
  • owner: kindgi.client.TriggerOwner
  • mailbox: kindgi.client.MailTriggerMailbox
  • folder: str | None (optional)
  • poll_seconds: int (pollSeconds on the wire)
  • runs_per_hour: int (runsPerHour on the wire)
  • label: str | None
  • status: Union[Literal['active', 'paused'], str]
  • status_reason: str | None (statusReason on the wire) (optional)
  • version: int | None (optional)
  • account: kindgi.client.Account | None (optional)
  • last_polled_at: AwareDatetime | None (lastPolledAt on the wire) (optional)
  • tools_allowed_unattended: list[kindgi.client.ToolsAllowedUnattendedItem] | None (toolsAllowedUnattended on the wire) (optional)
  • last_fired_at: AwareDatetime | None (lastFiredAt on the wire)
  • created_at: AwareDatetime (createdAt on the wire)
  • updated_at: AwareDatetime (updatedAt on the wire)

MailTriggerVersion

Section titled “MailTriggerVersion”

One version of a mail trigger: what it was from createdAt until the next. A new mail's run uses the newest when it starts, and keeps it.

  • trigger_id: str (triggerId on the wire)
  • version: int
  • created_at: AwareDatetime (createdAt on the wire)
  • created_by: str | None (createdBy on the wire) (optional)
  • cause: Union[Literal['register', 'edit', 'owner', 'first-fire', 'unversioned-edit', 'pin'], str]
  • definition: kindgi.client.MailTriggerDefinition

MailTriggerVersionPage

Section titled “MailTriggerVersionPage”

Newest first.

  • data: list[kindgi.client.MailTriggerVersion]
  • has_more: bool (hasMore on the wire)
  • next_cursor: str | None (nextCursor on the wire) (optional)

MemoryErasure

Section titled “MemoryErasure”
  • id: uuid.UUID
  • selector_kind: Union[Literal['fact', 'participant', 'external', 'conversation'], str] (selectorKind on the wire)
  • selector: kindgi.client.MemoryErasureFactSelector | kindgi.client.MemoryErasureSubjectSelector | kindgi.client.MemoryErasureConversationSelector | None (optional)
  • status: Union[Literal['pending', 'running', 'waiting-on-run', 'completed', 'failed'], str]
  • phase: Union[Literal['seed', 'expand', 'settle', 'erase', 'done'], str]
  • requested_by: str (requestedBy on the wire)
  • matchable: bool
  • counts: dict[str, CountsAdditionalProperty]
  • attempts: int
  • last_error: str | None (lastError on the wire) (optional)
  • waiting_on: kindgi.client.WaitingOn | None (waitingOn on the wire) (optional)
  • forced: Optional[Literal[True]] (optional)
  • settle_rounds_capped: Optional[Literal[True]] (settleRoundsCapped on the wire) (optional)
  • created_at: AwareDatetime (createdAt on the wire)
  • started_at: AwareDatetime | None (startedAt on the wire) (optional)
  • completed_at: AwareDatetime | None (completedAt on the wire) (optional)
  • replayed_at: AwareDatetime | None (replayedAt on the wire) (optional)

MemoryErasureConversationSelector

Section titled “MemoryErasureConversationSelector”

One conversation.

  • conversation_id: str (conversationId on the wire)

MemoryErasureCreated

Section titled “MemoryErasureCreated”
  • id: uuid.UUID
  • selector_kind: Union[Literal['fact', 'participant', 'external', 'conversation'], str] (selectorKind on the wire)
  • selector: kindgi.client.MemoryErasureFactSelector | kindgi.client.MemoryErasureSubjectSelector | kindgi.client.MemoryErasureConversationSelector | None (optional)
  • status: Union[Literal['pending', 'running', 'waiting-on-run', 'completed', 'failed'], str]
  • phase: Union[Literal['seed', 'expand', 'settle', 'erase', 'done'], str]
  • requested_by: str (requestedBy on the wire)
  • matchable: bool
  • counts: dict[str, CountsAdditionalProperty]
  • attempts: int
  • last_error: str | None (lastError on the wire) (optional)
  • waiting_on: kindgi.client.WaitingOn | None (waitingOn on the wire) (optional)
  • forced: Optional[Literal[True]] (optional)
  • settle_rounds_capped: Optional[Literal[True]] (settleRoundsCapped on the wire) (optional)
  • created_at: AwareDatetime (createdAt on the wire)
  • started_at: AwareDatetime | None (startedAt on the wire) (optional)
  • completed_at: AwareDatetime | None (completedAt on the wire) (optional)
  • replayed_at: AwareDatetime | None (replayedAt on the wire) (optional)
  • warnings: list[kindgi.client.Warning1] | None (optional)

MemoryErasureFactSelector

Section titled “MemoryErasureFactSelector”

One fact.

  • fact_id: str (factId on the wire)

MemoryErasureLedger

Section titled “MemoryErasureLedger”
  • data: list[kindgi.client.MemoryErasureLedgerEntry]

MemoryErasureLedgerEntry

Section titled “MemoryErasureLedgerEntry”
  • id: uuid.UUID
  • selector_kind: Union[Literal['fact', 'participant', 'external', 'conversation'], str] (selectorKind on the wire)
  • selector_hmac: str | None (selectorHmac on the wire) (optional)
  • key_id: str | None (keyId on the wire) (optional)
  • requested_by: str (requestedBy on the wire)
  • status: Union[Literal['pending', 'running', 'waiting-on-run', 'completed', 'failed'], str]
  • created_at: AwareDatetime (createdAt on the wire)
  • completed_at: AwareDatetime | None (completedAt on the wire) (optional)

MemoryErasurePage

Section titled “MemoryErasurePage”
  • data: list[kindgi.client.MemoryErasure]
  • has_more: bool (hasMore on the wire)
  • next_cursor: str | None (nextCursor on the wire) (optional)

MemoryErasureSubjectSelector

Section titled “MemoryErasureSubjectSelector”

A person: an app's end user (participant), or an external subject facts name. Erasing a Kindgi user isn't offered.

  • subject: kindgi.client.Subject

Metadatum

Section titled “Metadatum”
  • root: str

Methods

Section titled “Methods”

The ways in this deployment allows, for a sign-in page to show. Absent from older servers.

  • identity_providers: bool (identityProviders on the wire)
  • api_token: bool (apiToken on the wire)
  • session_cookie: Optional[Annotated[Union[Literal['secure', 'plain'], str], <kindgi.client._open.OpenEnum object at 0x10980e890>]] (sessionCookie on the wire) (optional)
  • email_link: kindgi.client.EmailLink | None (emailLink on the wire) (optional)

Metric

Section titled “Metric”
  • name: Union[Literal['weightedYesShare', 'judgedCoverage', 'weightedPrecisionAtK'], str]
  • k: int | None (optional)
  • min_candidate: float | None (minCandidate on the wire) (optional)
  • max_drop: float | None (maxDrop on the wire) (optional)

Metrics

Section titled “Metrics”
  • weighted_yes_share: kindgi.client.ComparisonMetric (weightedYesShare on the wire)
  • judged_coverage: kindgi.client.ComparisonMetric (judgedCoverage on the wire)
  • weighted_precision_at_k: kindgi.client.ComparisonMetric (weightedPrecisionAtK on the wire)

MintPublicRunTokenBody

Section titled “MintPublicRunTokenBody”
  • run_ids: list[kindgi.client.RunId] (runIds on the wire)
  • expires_in_seconds: int | None (expiresInSeconds on the wire) (optional)

MintPublicRunTokenResult

Section titled “MintPublicRunTokenResult”
  • token: str
  • expires_at: AwareDatetime (expiresAt on the wire)
  • run_ids: list[str] (runIds on the wire)

MintSystemKeyBody

Section titled “MintSystemKeyBody”
  • scopes: list[Literal['system:tenants', 'system:tenants:create', 'system:tenants:image-prefix', 'system:tenants:production', 'system:tenants:limits', 'system:tenants:contacts', 'system:tenants:purge', 'system:suspend', 'system:deployments', 'system:pack-env', 'system:usage:read', 'system:license', 'kindgi:system']]
  • label: str | None (optional)
  • expires_at: AwareDatetime | None (expiresAt on the wire) (optional)

MintSystemKeyResult

Section titled “MintSystemKeyResult”

The new system key, plus its secret.

  • id: str
  • label: str | None (optional)
  • scopes: list[Annotated[Union[Literal['system:tenants', 'system:tenants:create', 'system:tenants:image-prefix', 'system:tenants:production', 'system:tenants:limits', 'system:tenants:contacts', 'system:tenants:purge', 'system:suspend', 'system:deployments', 'system:pack-env', 'system:usage:read', 'system:license', 'kindgi:system'], str], <kindgi.client._open.OpenEnum object at 0x10980e890>]]
  • created_at: AwareDatetime (createdAt on the wire)
  • expires_at: AwareDatetime | None (expiresAt on the wire) (optional)
  • revoked_at: AwareDatetime | None (revokedAt on the wire) (optional)
  • minted_by: str (mintedBy on the wire)
  • token: str

MintTokenBody

Section titled “MintTokenBody”

A new API key. for is whom it acts for: the caller by default; only a tenant admin mints for someone else.

  • for_: kindgi.client.ApiKeyPrincipal | None (for on the wire) (optional)
  • role: Optional[Literal['admin', 'member']] (optional)
  • capabilities: list[kindgi.client.Capability] | None (optional)
  • label: str | None (optional)
  • expires_at: AwareDatetime | None (expiresAt on the wire) (optional)
  • project_id: uuid.UUID | None (projectId on the wire) (optional)

MintTokenResult

Section titled “MintTokenResult”

The new key, plus its secret.

  • token_id: uuid.UUID (tokenId on the wire)
  • principal: kindgi.client.ApiKeyPrincipal | None (optional)
  • role: Union[Literal['admin', 'member'], str]
  • capabilities: list[kindgi.client.Capability]
  • label: str | None (optional)
  • project_id: uuid.UUID | None (projectId on the wire) (optional)
  • created_by: str | None (createdBy on the wire) (optional)
  • created_at: AwareDatetime (createdAt on the wire)
  • expires_at: AwareDatetime | None (expiresAt on the wire) (optional)
  • revoked_at: AwareDatetime | None (revokedAt on the wire) (optional)
  • last_used_at: AwareDatetime | None (lastUsedAt on the wire) (optional)
  • token: str

Model

Section titled “Model”

For a drafter that used a model: which.

  • provider_id: str (providerId on the wire)
  • model: str

Model1

Section titled “Model1”

For a prompt pass: the provider and model that drafts the templates.

  • provider_id: str (providerId on the wire)
  • model: str

Model2

Section titled “Model2”

For a prompt pass: the tenant's provider and model that drafts the templates.

  • provider_id: str (providerId on the wire)
  • model: str

Model3

Section titled “Model3”
  • provider_id: str (providerId on the wire)
  • model: str
  • runs: int

Model4

Section titled “Model4”
  • provider_id: str (providerId on the wire)
  • model: str

ModelCallError

Section titled “ModelCallError”

Why a model call failed (status: failed).

  • message: str

ModelCallThinking

Section titled “ModelCallThinking”

The call's thinking. asked without level: nothing was sent (the model doesn't think, or its adapter doesn't say). level without asked: the model's thinking.default. asked and level differ: the level was rounded to one the model takes, and the call warned thinking-level-adjusted.

  • asked: Optional[Annotated[Union[Literal['lowest', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'], str], <kindgi.client._open.OpenEnum object at 0x10980e890>]] (optional)
  • level: Optional[Annotated[Union[Literal['lowest', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'], str], <kindgi.client._open.OpenEnum object at 0x10980e890>]] (optional)
  • sent: dict[str, str] | None (optional)

ModelCallTokens

Section titled “ModelCallTokens”

The call's tokens. promptTokens / completionTokens are the totals; cacheReadTokens / cacheWriteTokens are parts of promptTokens, reasoningTokens of completionTokens, present when the provider reports them.

  • prompt_tokens: int (promptTokens on the wire)
  • completion_tokens: int (completionTokens on the wire)
  • cache_read_tokens: int | None (cacheReadTokens on the wire) (optional)
  • cache_write_tokens: int | None (cacheWriteTokens on the wire) (optional)
  • reasoning_tokens: int | None (reasoningTokens on the wire) (optional)

ModelInfo

Section titled “ModelInfo”
  • name: str
  • context_window: int (contextWindow on the wire)
  • features: list[Annotated[Union[Literal['structured-output', 'vision', 'audio-input', 'audio-output', 'tool-use', 'parallel-tool-use', 'thinking', 'long-context', 'code-execution', 'web-search', 'file-search', 'streaming', 'batch'], str], <kindgi.client._open.OpenEnum object at 0x10980e890>]]
  • cost: kindgi.client.ProviderCost
  • p95_latency_ms: float | None (p95LatencyMs on the wire) (optional)
  • max_output_tokens: int | None (maxOutputTokens on the wire) (optional)
  • sampling: bool | None (optional)
  • thinking: kindgi.client.ModelThinking | None (optional)
  • description: str | None (optional)

ModelThinking

Section titled “ModelThinking”

How the model thinks before it answers, and the levels it takes, so a call's level (an agent's model settings, or a judge's lowest) is sent as one it takes: any other is rounded to the next one it takes, or its highest, with a thinking-level-adjusted warning. Absent: it doesn't think, or nothing is known, and nothing is sent for it.

  • mode: Union[Literal['adaptive', 'always'], str]
  • lowest: str
  • levels: list[Annotated[Union[Literal['minimal', 'low', 'medium', 'high', 'xhigh', 'max'], str], <kindgi.client._open.OpenEnum object at 0x10980e890>]] | None (optional)
  • default: Optional[Annotated[Union[Literal['lowest', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'], str], <kindgi.client._open.OpenEnum object at 0x10980e890>]] (optional)

MyKeyLimits

Section titled “MyKeyLimits”

The caller's API key, when it is one, and what it limits.

  • token_id: str (tokenId on the wire)
  • role: Optional[Annotated[Union[Literal['admin', 'member'], str], <kindgi.client._open.OpenEnum object at 0x10980e890>]] (optional)
  • project_id: str | None (projectId on the wire) (optional)

MyOrgAccess

Section titled “MyOrgAccess”
  • org_id: str (orgId on the wire)
  • name: str
  • role: Union[Literal['admin', 'member'], str]

MyPermissions

Section titled “MyPermissions”

What the caller may do, with its API key's limits applied: tenant admin and member, its reviewer role, its key's limits and capabilities, the projects it may read with its role in each and how it holds it, its orgs and teams, and what each project role allows. Only what the caller may see: nothing names a project it can't read, or anyone else's role.

  • tenant_id: uuid.UUID (tenantId on the wire)
  • tenant: kindgi.client.MyTenantAccess
  • reviewer: kindgi.client.MyReviewerAccess | None (optional)
  • key: kindgi.client.MyKeyLimits | None (optional)
  • token_capabilities: list[str] (tokenCapabilities on the wire)
  • projects: list[kindgi.client.MyProjectAccess]
  • orgs: list[kindgi.client.MyOrgAccess]
  • teams: list[kindgi.client.MyTeamAccess]
  • capabilities: kindgi.client.RoleCapabilities
  • read_only_notice: str | None (readOnlyNotice on the wire) (optional)
  • license_operator_only: bool | None (licenseOperatorOnly on the wire) (optional)

MyProjectAccess

Section titled “MyProjectAccess”
  • project_id: str (projectId on the wire)
  • name: str
  • role: Union[Literal['owner', 'admin', 'editor', 'viewer'], str]
  • via: list[Annotated[kindgi.client.AccessPathDirect | kindgi.client.AccessPathTeam | kindgi.client.AccessPathOrgAdmin | kindgi.client.AccessPathTenantAdmin | kindgi.client.AccessPathUnrecognized, <kindgi.client._open.OpenUnion object at 0x10a3da610>]]

MyReviewerAccess

Section titled “MyReviewerAccess”
  • role: Union[Literal['standard', 'senior', 'admin'], str]
  • id: str | None (optional)
  • decides: list[Annotated[Union[Literal['standard', 'senior', 'admin'], str], <kindgi.client._open.OpenEnum object at 0x10980e890>]]
  • can_decide: bool (canDecide on the wire)

MyTeamAccess

Section titled “MyTeamAccess”
  • team_id: str (teamId on the wire)
  • name: str
  • role: Union[Literal['admin', 'member'], str]

MyTenantAccess

Section titled “MyTenantAccess”
  • admin: bool
  • member: bool | None (optional)