@meshery/schemas 1.3.111 → 1.3.112
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cloudApi.d.mts +5024 -4404
- package/dist/cloudApi.d.ts +5024 -4404
- package/dist/cloudApi.js +1 -1
- package/dist/cloudApi.mjs +1 -1
- package/dist/constructs/v1beta3/oauth_consent/OauthConsent.d.ts +466 -0
- package/dist/constructs/v1beta3/oauth_consent/OauthConsent.js +1 -0
- package/dist/constructs/v1beta3/oauth_consent/OauthConsent.mjs +0 -0
- package/dist/constructs/v1beta3/oauth_consent/OauthConsentSchema.d.ts +2 -0
- package/dist/constructs/v1beta3/oauth_consent/OauthConsentSchema.js +199 -0
- package/dist/constructs/v1beta3/oauth_consent/OauthConsentSchema.mjs +199 -0
- package/dist/constructs/v1beta3/token/Token.d.ts +131 -5
- package/dist/constructs/v1beta3/token/TokenSchema.js +3 -3
- package/dist/constructs/v1beta3/token/TokenSchema.mjs +3 -3
- package/dist/constructs/v1beta3/user/User.d.ts +222 -2
- package/dist/constructs/v1beta3/user/UserSchema.js +1 -1
- package/dist/constructs/v1beta3/user/UserSchema.mjs +1 -1
- package/dist/index.d.mts +85 -2
- package/dist/index.d.ts +85 -2
- package/dist/mesheryApi.d.mts +1 -1
- package/dist/mesheryApi.d.ts +1 -1
- package/package.json +1 -1
|
@@ -19,7 +19,7 @@ export interface paths {
|
|
|
19
19
|
put?: never;
|
|
20
20
|
/**
|
|
21
21
|
* Generate token
|
|
22
|
-
* @description Generates a token for the authenticated user.
|
|
22
|
+
* @description Generates a token for the authenticated user. `name` and `purpose` are query parameters, as before. The optional body (`TokenCreatePayload`) limits the token: `keychainIds` restricts it to the keys of those keychains, and `expiresAt` ends its life. Omit the body, or both fields, for an unrestricted token that never expires. An unknown keychain ID, an explicit empty `keychainIds`, an `expiresAt` in the past, or a keychain the caller cannot see is refused with 400. A request authenticated with a keychain-scoped token (`keychainScoped` true, or a non-empty `keychainIds`) answers 403 and mints nothing, whatever the body. A session or unrestricted token is unchanged. See docs/token-scoping-contract.md.
|
|
23
23
|
*/
|
|
24
24
|
post: operations["generateToken"];
|
|
25
25
|
/**
|
|
@@ -61,7 +61,7 @@ export interface paths {
|
|
|
61
61
|
};
|
|
62
62
|
/**
|
|
63
63
|
* Issue indefinite lifetime token
|
|
64
|
-
* @description Creates a non-expiring user token for provider admin use cases.
|
|
64
|
+
* @description Creates a non-expiring user token for provider admin use cases. A request authenticated with a keychain-scoped token (`keychainScoped` true, or a non-empty `keychainIds`) answers 403 and mints nothing, whatever the query. A session or unrestricted token is unchanged. See docs/token-scoping-contract.md.
|
|
65
65
|
*/
|
|
66
66
|
get: operations["issueIndefiniteLifetimeToken"];
|
|
67
67
|
put?: never;
|
|
@@ -81,7 +81,7 @@ export interface paths {
|
|
|
81
81
|
};
|
|
82
82
|
/**
|
|
83
83
|
* Authorize native client sign-in
|
|
84
|
-
* @description Browser-facing step of the native client sign-in flow (RFC 8252 loopback redirect with RFC 7636 PKCE). Requires the session cookie of a signed-in user and the Create Token permission. Validates the request. When the request names the client application (`client`) and its version (`clientVersion`) and that version is below the provider minimum, it renders the update page with status 426 and issues nothing. Otherwise it stores a single-use authorization code that expires after 60 seconds, bound to the user, the client name and the PKCE code challenge, and redirects the browser to http://127.0.0.1:{port}/callback with code and state query parameters. Only the 127.0.0.1 loopback IP literal is ever used; no token or cookie is placed in the redirect; no consent page is shown.
|
|
84
|
+
* @description Browser-facing step of the native client sign-in flow (RFC 8252 loopback redirect with RFC 7636 PKCE). Requires the session cookie of a signed-in user and the Create Token permission. Validates the request. When the request names the client application (`client`) and its version (`clientVersion`) and that version is below the provider minimum, it renders the update page with status 426 and issues nothing. Otherwise it stores a single-use authorization code that expires after 60 seconds, bound to the user, the client name and the PKCE code challenge, and redirects the browser to http://127.0.0.1:{port}/callback with code and state query parameters. Only the 127.0.0.1 loopback IP literal is ever used; no token or cookie is placed in the redirect; no consent page is shown. A request authenticated with a keychain-scoped token (`keychainScoped` true, or a non-empty `keychainIds`) answers 403 and mints nothing, including no authorization code, whatever the query. A session or unrestricted token is unchanged. See docs/token-scoping-contract.md.
|
|
85
85
|
*/
|
|
86
86
|
get: operations["getNativeClientAuthorization"];
|
|
87
87
|
put?: never;
|
|
@@ -176,7 +176,7 @@ export interface paths {
|
|
|
176
176
|
export type webhooks = Record<string, never>;
|
|
177
177
|
export interface components {
|
|
178
178
|
schemas: {
|
|
179
|
-
/** @description Represents a user-owned API token or OAuth session. */
|
|
179
|
+
/** @description Represents a user-owned API token or OAuth session. A token may carry two optional limits. `keychainIds` restricts which keys it may use, and `expiresAt` ends its life. A token with neither is unrestricted and never expires, which is what every token issued before these fields existed is. A token with neither limit set is unrestricted only when keychainScoped is false or absent. `keychainScoped` is the server's stored record of whether the token is limited to its keychains' keys. See the token scoping contract in docs/token-scoping-contract.md. */
|
|
180
180
|
UserToken: {
|
|
181
181
|
/**
|
|
182
182
|
* Format: uuid
|
|
@@ -210,6 +210,15 @@ export interface components {
|
|
|
210
210
|
* @description Timestamp when the token was last updated.
|
|
211
211
|
*/
|
|
212
212
|
updatedAt: string;
|
|
213
|
+
/** @description IDs of the keychains this token is limited to. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent, so every token issued before this field existed keeps working unchanged. A non-empty list always makes the token scoped, whatever keychainScoped says. A scoped token may use only keys that belong to these keychains, intersected with the owner's keys in the organization of the request: the effective keys are never more than the user's own. A scoped token with an empty list holds no keys; it is not unrestricted. A server that stores keychainIds always stores keychainScoped true. Unknown keychain IDs are refused when the token is created. */
|
|
214
|
+
keychainIds?: string[];
|
|
215
|
+
/**
|
|
216
|
+
* Format: date-time
|
|
217
|
+
* @description Time after which the token is no longer accepted. Absent or null means the token never expires, which is the case for every token issued before this field existed. Set when the token is created and not changed afterwards.
|
|
218
|
+
*/
|
|
219
|
+
expiresAt?: string | null;
|
|
220
|
+
/** @description Whether the token is limited to the keys of its keychains. Set by the server at creation: true when the create has a non-empty `keychainIds`. A re-consent that narrows an unrestricted token (false) changes it to true; no other operation changes it, and it is never reset to false. It is read-only to clients. It is stored on the token and never reset, so a scoped token whose keychains have all been deleted stays scoped and holds no keys; a non-empty set of keychain mappings also always means scoped. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent. A true flag is never unrestricted, even with an empty list. */
|
|
221
|
+
readonly keychainScoped?: boolean;
|
|
213
222
|
};
|
|
214
223
|
/** @description Carries the token that revokeToken revokes. */
|
|
215
224
|
TokenPayload: {
|
|
@@ -258,6 +267,30 @@ export interface components {
|
|
|
258
267
|
/** @description Always "Bearer". */
|
|
259
268
|
tokenType?: string;
|
|
260
269
|
};
|
|
270
|
+
/** @description Client-settable limits for a token created with generateToken. Every field is optional; an empty body creates an unrestricted token that never expires. The token's name and purpose are query parameters of the operation, and its id, owner and timestamps are server-generated. */
|
|
271
|
+
TokenCreatePayload: {
|
|
272
|
+
/** @description IDs of the keychains the token is limited to. A non-empty list limits the token to the keys of those keychains, intersected with the owner's keys in the request's organization. An absent list creates an unrestricted token. An explicit empty list is refused with 400, so a selection that ends up empty never mints a full-access token. The server records keychainScoped from this list; clients do not set it. */
|
|
273
|
+
keychainIds?: string[];
|
|
274
|
+
/**
|
|
275
|
+
* Format: date-time
|
|
276
|
+
* @description Time after which the token is no longer accepted. Absent or null means it never expires.
|
|
277
|
+
*/
|
|
278
|
+
expiresAt?: string | null;
|
|
279
|
+
};
|
|
280
|
+
/** @description Server-side read result of looking up one presented token by its ID (the token's `jti`) in the token store. It is not a request or response body: the server reads it before any handler runs to decide whether the token is accepted and whether its keys are narrowed to its keychains. The server reports `keychainScoped` true when the stored flag is true or the token has any keychain mapping, so a consumer deciding from this result fails closed. See docs/token-scoping-contract.md. */
|
|
281
|
+
TokenStanding: {
|
|
282
|
+
/**
|
|
283
|
+
* Format: uuid
|
|
284
|
+
* @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
|
|
285
|
+
*/
|
|
286
|
+
id: string;
|
|
287
|
+
/** @description Whether the stored token has been retired (deleted). */
|
|
288
|
+
revoked: boolean;
|
|
289
|
+
/** @description Whether the stored token's `expiresAt` is at or before the time of the lookup, evaluated by the store. A token with no `expiresAt` never expires. */
|
|
290
|
+
expired: boolean;
|
|
291
|
+
/** @description True when the token's stored `keychainScoped` flag is true or the token has any keychain mapping. When true the token is limited to the keys of its keychains, and holds no keys if every one of them has been deleted. The lookup's `keychain_scoped` result column is a computed alias for this value (the stored flag OR any keychain mapping), so a query-mapping consumer does not read the raw stored flag. */
|
|
292
|
+
keychainScoped: boolean;
|
|
293
|
+
};
|
|
261
294
|
/** @description Query fields of GET /api/identity/native/authorize. The signed-in session issues the authorization code from these fields. */
|
|
262
295
|
NativeAuthorizationPayload: {
|
|
263
296
|
/** @description Display name of the native client. */
|
|
@@ -324,6 +357,15 @@ export interface components {
|
|
|
324
357
|
* @description Timestamp when the token was last updated.
|
|
325
358
|
*/
|
|
326
359
|
updatedAt: string;
|
|
360
|
+
/** @description IDs of the keychains this token is limited to. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent, so every token issued before this field existed keeps working unchanged. A non-empty list always makes the token scoped, whatever keychainScoped says. A scoped token may use only keys that belong to these keychains, intersected with the owner's keys in the organization of the request: the effective keys are never more than the user's own. A scoped token with an empty list holds no keys; it is not unrestricted. A server that stores keychainIds always stores keychainScoped true. Unknown keychain IDs are refused when the token is created. */
|
|
361
|
+
keychainIds?: string[];
|
|
362
|
+
/**
|
|
363
|
+
* Format: date-time
|
|
364
|
+
* @description Time after which the token is no longer accepted. Absent or null means the token never expires, which is the case for every token issued before this field existed. Set when the token is created and not changed afterwards.
|
|
365
|
+
*/
|
|
366
|
+
expiresAt?: string | null;
|
|
367
|
+
/** @description Whether the token is limited to the keys of its keychains. Set by the server at creation: true when the create has a non-empty `keychainIds`. A re-consent that narrows an unrestricted token (false) changes it to true; no other operation changes it, and it is never reset to false. It is read-only to clients. It is stored on the token and never reset, so a scoped token whose keychains have all been deleted stays scoped and holds no keys; a non-empty set of keychain mappings also always means scoped. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent. A true flag is never unrestricted, even with an empty list. */
|
|
368
|
+
readonly keychainScoped?: boolean;
|
|
327
369
|
}[];
|
|
328
370
|
/** @description Total number of tokens across all pages. */
|
|
329
371
|
totalCount: number;
|
|
@@ -506,6 +548,15 @@ export interface operations {
|
|
|
506
548
|
* @description Timestamp when the token was last updated.
|
|
507
549
|
*/
|
|
508
550
|
updatedAt: string;
|
|
551
|
+
/** @description IDs of the keychains this token is limited to. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent, so every token issued before this field existed keeps working unchanged. A non-empty list always makes the token scoped, whatever keychainScoped says. A scoped token may use only keys that belong to these keychains, intersected with the owner's keys in the organization of the request: the effective keys are never more than the user's own. A scoped token with an empty list holds no keys; it is not unrestricted. A server that stores keychainIds always stores keychainScoped true. Unknown keychain IDs are refused when the token is created. */
|
|
552
|
+
keychainIds?: string[];
|
|
553
|
+
/**
|
|
554
|
+
* Format: date-time
|
|
555
|
+
* @description Time after which the token is no longer accepted. Absent or null means the token never expires, which is the case for every token issued before this field existed. Set when the token is created and not changed afterwards.
|
|
556
|
+
*/
|
|
557
|
+
expiresAt?: string | null;
|
|
558
|
+
/** @description Whether the token is limited to the keys of its keychains. Set by the server at creation: true when the create has a non-empty `keychainIds`. A re-consent that narrows an unrestricted token (false) changes it to true; no other operation changes it, and it is never reset to false. It is read-only to clients. It is stored on the token and never reset, so a scoped token whose keychains have all been deleted stays scoped and holds no keys; a non-empty set of keychain mappings also always means scoped. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent. A true flag is never unrestricted, even with an empty list. */
|
|
559
|
+
readonly keychainScoped?: boolean;
|
|
509
560
|
}[];
|
|
510
561
|
/** @description Total number of tokens across all pages. */
|
|
511
562
|
totalCount: number;
|
|
@@ -548,7 +599,19 @@ export interface operations {
|
|
|
548
599
|
path?: never;
|
|
549
600
|
cookie?: never;
|
|
550
601
|
};
|
|
551
|
-
requestBody?:
|
|
602
|
+
requestBody?: {
|
|
603
|
+
content: {
|
|
604
|
+
"application/json": {
|
|
605
|
+
/** @description IDs of the keychains the token is limited to. A non-empty list limits the token to the keys of those keychains, intersected with the owner's keys in the request's organization. An absent list creates an unrestricted token. An explicit empty list is refused with 400, so a selection that ends up empty never mints a full-access token. The server records keychainScoped from this list; clients do not set it. */
|
|
606
|
+
keychainIds?: string[];
|
|
607
|
+
/**
|
|
608
|
+
* Format: date-time
|
|
609
|
+
* @description Time after which the token is no longer accepted. Absent or null means it never expires.
|
|
610
|
+
*/
|
|
611
|
+
expiresAt?: string | null;
|
|
612
|
+
};
|
|
613
|
+
};
|
|
614
|
+
};
|
|
552
615
|
responses: {
|
|
553
616
|
/** @description Token generated */
|
|
554
617
|
201: {
|
|
@@ -591,6 +654,15 @@ export interface operations {
|
|
|
591
654
|
* @description Timestamp when the token was last updated.
|
|
592
655
|
*/
|
|
593
656
|
updatedAt: string;
|
|
657
|
+
/** @description IDs of the keychains this token is limited to. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent, so every token issued before this field existed keeps working unchanged. A non-empty list always makes the token scoped, whatever keychainScoped says. A scoped token may use only keys that belong to these keychains, intersected with the owner's keys in the organization of the request: the effective keys are never more than the user's own. A scoped token with an empty list holds no keys; it is not unrestricted. A server that stores keychainIds always stores keychainScoped true. Unknown keychain IDs are refused when the token is created. */
|
|
658
|
+
keychainIds?: string[];
|
|
659
|
+
/**
|
|
660
|
+
* Format: date-time
|
|
661
|
+
* @description Time after which the token is no longer accepted. Absent or null means the token never expires, which is the case for every token issued before this field existed. Set when the token is created and not changed afterwards.
|
|
662
|
+
*/
|
|
663
|
+
expiresAt?: string | null;
|
|
664
|
+
/** @description Whether the token is limited to the keys of its keychains. Set by the server at creation: true when the create has a non-empty `keychainIds`. A re-consent that narrows an unrestricted token (false) changes it to true; no other operation changes it, and it is never reset to false. It is read-only to clients. It is stored on the token and never reset, so a scoped token whose keychains have all been deleted stays scoped and holds no keys; a non-empty set of keychain mappings also always means scoped. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent. A true flag is never unrestricted, even with an empty list. */
|
|
665
|
+
readonly keychainScoped?: boolean;
|
|
594
666
|
}[];
|
|
595
667
|
/** @description Total number of tokens across all pages. */
|
|
596
668
|
totalCount: number;
|
|
@@ -619,6 +691,15 @@ export interface operations {
|
|
|
619
691
|
"text/plain": string;
|
|
620
692
|
};
|
|
621
693
|
};
|
|
694
|
+
/** @description Forbidden */
|
|
695
|
+
403: {
|
|
696
|
+
headers: {
|
|
697
|
+
[name: string]: unknown;
|
|
698
|
+
};
|
|
699
|
+
content: {
|
|
700
|
+
"text/plain": string;
|
|
701
|
+
};
|
|
702
|
+
};
|
|
622
703
|
/** @description Internal server error */
|
|
623
704
|
500: {
|
|
624
705
|
headers: {
|
|
@@ -683,6 +764,15 @@ export interface operations {
|
|
|
683
764
|
* @description Timestamp when the token was last updated.
|
|
684
765
|
*/
|
|
685
766
|
updatedAt: string;
|
|
767
|
+
/** @description IDs of the keychains this token is limited to. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent, so every token issued before this field existed keeps working unchanged. A non-empty list always makes the token scoped, whatever keychainScoped says. A scoped token may use only keys that belong to these keychains, intersected with the owner's keys in the organization of the request: the effective keys are never more than the user's own. A scoped token with an empty list holds no keys; it is not unrestricted. A server that stores keychainIds always stores keychainScoped true. Unknown keychain IDs are refused when the token is created. */
|
|
768
|
+
keychainIds?: string[];
|
|
769
|
+
/**
|
|
770
|
+
* Format: date-time
|
|
771
|
+
* @description Time after which the token is no longer accepted. Absent or null means the token never expires, which is the case for every token issued before this field existed. Set when the token is created and not changed afterwards.
|
|
772
|
+
*/
|
|
773
|
+
expiresAt?: string | null;
|
|
774
|
+
/** @description Whether the token is limited to the keys of its keychains. Set by the server at creation: true when the create has a non-empty `keychainIds`. A re-consent that narrows an unrestricted token (false) changes it to true; no other operation changes it, and it is never reset to false. It is read-only to clients. It is stored on the token and never reset, so a scoped token whose keychains have all been deleted stays scoped and holds no keys; a non-empty set of keychain mappings also always means scoped. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent. A true flag is never unrestricted, even with an empty list. */
|
|
775
|
+
readonly keychainScoped?: boolean;
|
|
686
776
|
}[];
|
|
687
777
|
/** @description Total number of tokens across all pages. */
|
|
688
778
|
totalCount: number;
|
|
@@ -773,6 +863,15 @@ export interface operations {
|
|
|
773
863
|
* @description Timestamp when the token was last updated.
|
|
774
864
|
*/
|
|
775
865
|
updatedAt: string;
|
|
866
|
+
/** @description IDs of the keychains this token is limited to. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent, so every token issued before this field existed keeps working unchanged. A non-empty list always makes the token scoped, whatever keychainScoped says. A scoped token may use only keys that belong to these keychains, intersected with the owner's keys in the organization of the request: the effective keys are never more than the user's own. A scoped token with an empty list holds no keys; it is not unrestricted. A server that stores keychainIds always stores keychainScoped true. Unknown keychain IDs are refused when the token is created. */
|
|
867
|
+
keychainIds?: string[];
|
|
868
|
+
/**
|
|
869
|
+
* Format: date-time
|
|
870
|
+
* @description Time after which the token is no longer accepted. Absent or null means the token never expires, which is the case for every token issued before this field existed. Set when the token is created and not changed afterwards.
|
|
871
|
+
*/
|
|
872
|
+
expiresAt?: string | null;
|
|
873
|
+
/** @description Whether the token is limited to the keys of its keychains. Set by the server at creation: true when the create has a non-empty `keychainIds`. A re-consent that narrows an unrestricted token (false) changes it to true; no other operation changes it, and it is never reset to false. It is read-only to clients. It is stored on the token and never reset, so a scoped token whose keychains have all been deleted stays scoped and holds no keys; a non-empty set of keychain mappings also always means scoped. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent. A true flag is never unrestricted, even with an empty list. */
|
|
874
|
+
readonly keychainScoped?: boolean;
|
|
776
875
|
};
|
|
777
876
|
};
|
|
778
877
|
};
|
|
@@ -860,6 +959,15 @@ export interface operations {
|
|
|
860
959
|
* @description Timestamp when the token was last updated.
|
|
861
960
|
*/
|
|
862
961
|
updatedAt: string;
|
|
962
|
+
/** @description IDs of the keychains this token is limited to. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent, so every token issued before this field existed keeps working unchanged. A non-empty list always makes the token scoped, whatever keychainScoped says. A scoped token may use only keys that belong to these keychains, intersected with the owner's keys in the organization of the request: the effective keys are never more than the user's own. A scoped token with an empty list holds no keys; it is not unrestricted. A server that stores keychainIds always stores keychainScoped true. Unknown keychain IDs are refused when the token is created. */
|
|
963
|
+
keychainIds?: string[];
|
|
964
|
+
/**
|
|
965
|
+
* Format: date-time
|
|
966
|
+
* @description Time after which the token is no longer accepted. Absent or null means the token never expires, which is the case for every token issued before this field existed. Set when the token is created and not changed afterwards.
|
|
967
|
+
*/
|
|
968
|
+
expiresAt?: string | null;
|
|
969
|
+
/** @description Whether the token is limited to the keys of its keychains. Set by the server at creation: true when the create has a non-empty `keychainIds`. A re-consent that narrows an unrestricted token (false) changes it to true; no other operation changes it, and it is never reset to false. It is read-only to clients. It is stored on the token and never reset, so a scoped token whose keychains have all been deleted stays scoped and holds no keys; a non-empty set of keychain mappings also always means scoped. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent. A true flag is never unrestricted, even with an empty list. */
|
|
970
|
+
readonly keychainScoped?: boolean;
|
|
863
971
|
}[];
|
|
864
972
|
/** @description Total number of tokens across all pages. */
|
|
865
973
|
totalCount: number;
|
|
@@ -888,6 +996,15 @@ export interface operations {
|
|
|
888
996
|
"text/plain": string;
|
|
889
997
|
};
|
|
890
998
|
};
|
|
999
|
+
/** @description Forbidden */
|
|
1000
|
+
403: {
|
|
1001
|
+
headers: {
|
|
1002
|
+
[name: string]: unknown;
|
|
1003
|
+
};
|
|
1004
|
+
content: {
|
|
1005
|
+
"text/plain": string;
|
|
1006
|
+
};
|
|
1007
|
+
};
|
|
891
1008
|
/** @description Internal server error */
|
|
892
1009
|
500: {
|
|
893
1010
|
headers: {
|
|
@@ -1036,6 +1153,15 @@ export interface operations {
|
|
|
1036
1153
|
* @description Timestamp when the token was last updated.
|
|
1037
1154
|
*/
|
|
1038
1155
|
updatedAt: string;
|
|
1156
|
+
/** @description IDs of the keychains this token is limited to. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent, so every token issued before this field existed keeps working unchanged. A non-empty list always makes the token scoped, whatever keychainScoped says. A scoped token may use only keys that belong to these keychains, intersected with the owner's keys in the organization of the request: the effective keys are never more than the user's own. A scoped token with an empty list holds no keys; it is not unrestricted. A server that stores keychainIds always stores keychainScoped true. Unknown keychain IDs are refused when the token is created. */
|
|
1157
|
+
keychainIds?: string[];
|
|
1158
|
+
/**
|
|
1159
|
+
* Format: date-time
|
|
1160
|
+
* @description Time after which the token is no longer accepted. Absent or null means the token never expires, which is the case for every token issued before this field existed. Set when the token is created and not changed afterwards.
|
|
1161
|
+
*/
|
|
1162
|
+
expiresAt?: string | null;
|
|
1163
|
+
/** @description Whether the token is limited to the keys of its keychains. Set by the server at creation: true when the create has a non-empty `keychainIds`. A re-consent that narrows an unrestricted token (false) changes it to true; no other operation changes it, and it is never reset to false. It is read-only to clients. It is stored on the token and never reset, so a scoped token whose keychains have all been deleted stays scoped and holds no keys; a non-empty set of keychain mappings also always means scoped. A token is unrestricted only when keychainScoped is false or absent and keychainIds is empty or absent. A true flag is never unrestricted, even with an empty list. */
|
|
1164
|
+
readonly keychainScoped?: boolean;
|
|
1039
1165
|
};
|
|
1040
1166
|
};
|
|
1041
1167
|
};
|