@meshery/schemas 1.3.91 → 1.3.93
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 +71 -64
- package/dist/cloudApi.d.ts +71 -64
- package/dist/constructs/v1beta1/organization_smtp/OrganizationSmtp.d.ts +3 -3
- package/dist/constructs/v1beta1/organization_smtp/OrganizationSmtpSchema.js +1 -1
- package/dist/constructs/v1beta1/organization_smtp/OrganizationSmtpSchema.mjs +1 -1
- package/dist/constructs/v1beta1/registry/Registry.d.ts +9 -9
- package/dist/constructs/v1beta1/registry/RegistrySchema.js +3 -3
- package/dist/constructs/v1beta1/registry/RegistrySchema.mjs +3 -3
- package/dist/constructs/v1beta3/connection/Connection.d.ts +27 -27
- package/dist/constructs/v1beta3/connection/ConnectionSchema.js +3 -3
- package/dist/constructs/v1beta3/connection/ConnectionSchema.mjs +3 -3
- package/dist/constructs/v1beta3/environment/Environment.d.ts +29 -29
- package/dist/constructs/v1beta3/environment/EnvironmentSchema.js +1 -1
- package/dist/constructs/v1beta3/environment/EnvironmentSchema.mjs +1 -1
- package/dist/constructs/v1beta3/ledger/Ledger.d.ts +74 -35
- package/dist/constructs/v1beta3/ledger/LedgerSchema.js +20 -16
- package/dist/constructs/v1beta3/ledger/LedgerSchema.mjs +20 -16
- package/dist/constructs/v1beta3/profile/Profile.d.ts +3 -3
- package/dist/constructs/v1beta3/profile/ProfileSchema.js +1 -1
- package/dist/constructs/v1beta3/profile/ProfileSchema.mjs +1 -1
- package/dist/constructs/v1beta3/workspace/Workspace.d.ts +3 -3
- package/dist/constructs/v1beta3/workspace/WorkspaceSchema.js +1 -1
- package/dist/constructs/v1beta3/workspace/WorkspaceSchema.mjs +1 -1
- package/dist/mesheryApi.d.mts +44 -44
- package/dist/mesheryApi.d.ts +44 -44
- package/package.json +1 -1
package/dist/cloudApi.d.ts
CHANGED
|
@@ -387,16 +387,16 @@ type GetOrganizationSmtpEnvironmentApiResponse =
|
|
|
387
387
|
updatedAt?: string;
|
|
388
388
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
389
389
|
deletedAt?: string | null;
|
|
390
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
390
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
391
391
|
|
|
392
392
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
393
393
|
|
|
394
394
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
395
395
|
|
|
396
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
396
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
397
397
|
|
|
398
398
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
399
|
-
purpose?: "user" | "administrative"
|
|
399
|
+
purpose?: "user" | "administrative";
|
|
400
400
|
};
|
|
401
401
|
type GetOrganizationSmtpEnvironmentApiArg = {
|
|
402
402
|
/** Organization ID */
|
|
@@ -7143,16 +7143,16 @@ type GetConnectionsApiResponse = {
|
|
|
7143
7143
|
updatedAt?: string;
|
|
7144
7144
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
7145
7145
|
deletedAt?: string | null;
|
|
7146
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
7146
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
7147
7147
|
|
|
7148
7148
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
7149
7149
|
|
|
7150
7150
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
7151
7151
|
|
|
7152
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
7152
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
7153
7153
|
|
|
7154
7154
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
7155
|
-
purpose?: "user" | "administrative"
|
|
7155
|
+
purpose?: "user" | "administrative";
|
|
7156
7156
|
}[];
|
|
7157
7157
|
/** Specifies the version of the schema used for the definition. */
|
|
7158
7158
|
schemaVersion: string;
|
|
@@ -7413,16 +7413,16 @@ type RegisterConnectionApiResponse = {
|
|
|
7413
7413
|
updatedAt?: string;
|
|
7414
7414
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
7415
7415
|
deletedAt?: string | null;
|
|
7416
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
7416
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
7417
7417
|
|
|
7418
7418
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
7419
7419
|
|
|
7420
7420
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
7421
7421
|
|
|
7422
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
7422
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
7423
7423
|
|
|
7424
7424
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
7425
|
-
purpose?: "user" | "administrative"
|
|
7425
|
+
purpose?: "user" | "administrative";
|
|
7426
7426
|
}[];
|
|
7427
7427
|
/** Specifies the version of the schema used for the definition. */
|
|
7428
7428
|
schemaVersion: string;
|
|
@@ -7649,16 +7649,16 @@ type RegisterConnectionApiResponse = {
|
|
|
7649
7649
|
updatedAt?: string;
|
|
7650
7650
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
7651
7651
|
deletedAt?: string | null;
|
|
7652
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
7652
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
7653
7653
|
|
|
7654
7654
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
7655
7655
|
|
|
7656
7656
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
7657
7657
|
|
|
7658
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
7658
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
7659
7659
|
|
|
7660
7660
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
7661
|
-
purpose?: "user" | "administrative"
|
|
7661
|
+
purpose?: "user" | "administrative";
|
|
7662
7662
|
}[];
|
|
7663
7663
|
/** Specifies the version of the schema used for the definition. */
|
|
7664
7664
|
schemaVersion: string;
|
|
@@ -8047,16 +8047,16 @@ type GetConnectionByIdApiResponse = {
|
|
|
8047
8047
|
updatedAt?: string;
|
|
8048
8048
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
8049
8049
|
deletedAt?: string | null;
|
|
8050
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
8050
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
8051
8051
|
|
|
8052
8052
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
8053
8053
|
|
|
8054
8054
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
8055
8055
|
|
|
8056
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
8056
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
8057
8057
|
|
|
8058
8058
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
8059
|
-
purpose?: "user" | "administrative"
|
|
8059
|
+
purpose?: "user" | "administrative";
|
|
8060
8060
|
}[];
|
|
8061
8061
|
/** Specifies the version of the schema used for the definition. */
|
|
8062
8062
|
schemaVersion: string;
|
|
@@ -8288,16 +8288,16 @@ type UpdateConnectionApiResponse = {
|
|
|
8288
8288
|
updatedAt?: string;
|
|
8289
8289
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
8290
8290
|
deletedAt?: string | null;
|
|
8291
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
8291
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
8292
8292
|
|
|
8293
8293
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
8294
8294
|
|
|
8295
8295
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
8296
8296
|
|
|
8297
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
8297
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
8298
8298
|
|
|
8299
8299
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
8300
|
-
purpose?: "user" | "administrative"
|
|
8300
|
+
purpose?: "user" | "administrative";
|
|
8301
8301
|
}[];
|
|
8302
8302
|
/** Specifies the version of the schema used for the definition. */
|
|
8303
8303
|
schemaVersion: string;
|
|
@@ -8700,16 +8700,16 @@ type RecordConnectionHeartbeatApiResponse = {
|
|
|
8700
8700
|
updatedAt?: string;
|
|
8701
8701
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
8702
8702
|
deletedAt?: string | null;
|
|
8703
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
8703
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
8704
8704
|
|
|
8705
8705
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
8706
8706
|
|
|
8707
8707
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
8708
8708
|
|
|
8709
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
8709
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
8710
8710
|
|
|
8711
8711
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
8712
|
-
purpose?: "user" | "administrative"
|
|
8712
|
+
purpose?: "user" | "administrative";
|
|
8713
8713
|
}[];
|
|
8714
8714
|
/** Specifies the version of the schema used for the definition. */
|
|
8715
8715
|
schemaVersion: string;
|
|
@@ -12802,16 +12802,16 @@ type CreateEnvironmentApiResponse = {
|
|
|
12802
12802
|
updatedAt?: string;
|
|
12803
12803
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
12804
12804
|
deletedAt?: string | null;
|
|
12805
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
12805
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
12806
12806
|
|
|
12807
12807
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
12808
12808
|
|
|
12809
12809
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
12810
12810
|
|
|
12811
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
12811
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
12812
12812
|
|
|
12813
12813
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
12814
|
-
purpose?: "user" | "administrative"
|
|
12814
|
+
purpose?: "user" | "administrative";
|
|
12815
12815
|
};
|
|
12816
12816
|
type CreateEnvironmentApiArg = {
|
|
12817
12817
|
/** Body for creating environment */
|
|
@@ -12826,8 +12826,8 @@ type CreateEnvironmentApiArg = {
|
|
|
12826
12826
|
metadata?: {
|
|
12827
12827
|
[key: string]: any;
|
|
12828
12828
|
};
|
|
12829
|
-
/** The
|
|
12830
|
-
purpose?: "user"
|
|
12829
|
+
/** The purpose a client may give an environment on create or update: `user` (an ordinary environment). Profiles are not environments; they are their own construct at `/api/profiles`, assigned to workspaces. Omitted means `user` on create and unchanged on update. A server refuses any other value with 400, and never lets this field change an environment that already carries a privileged purpose. */
|
|
12830
|
+
purpose?: "user";
|
|
12831
12831
|
};
|
|
12832
12832
|
};
|
|
12833
12833
|
type GetEnvironmentsApiResponse = {
|
|
@@ -12859,16 +12859,16 @@ type GetEnvironmentsApiResponse = {
|
|
|
12859
12859
|
updatedAt?: string;
|
|
12860
12860
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
12861
12861
|
deletedAt?: string | null;
|
|
12862
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
12862
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
12863
12863
|
|
|
12864
12864
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
12865
12865
|
|
|
12866
12866
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
12867
12867
|
|
|
12868
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
12868
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
12869
12869
|
|
|
12870
12870
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
12871
|
-
purpose?: "user" | "administrative"
|
|
12871
|
+
purpose?: "user" | "administrative";
|
|
12872
12872
|
}[];
|
|
12873
12873
|
};
|
|
12874
12874
|
type GetEnvironmentsApiArg = {
|
|
@@ -12885,7 +12885,7 @@ type GetEnvironmentsApiArg = {
|
|
|
12885
12885
|
/** User's organization ID */
|
|
12886
12886
|
orgId: string;
|
|
12887
12887
|
/** Return only environments with this purpose; absent returns every purpose the caller may see. The filter only narrows the environments the caller can already list and grants no visibility - a caller who cannot see administrative environments receives an empty page for purpose=administrative. */
|
|
12888
|
-
purpose?: "user" | "administrative"
|
|
12888
|
+
purpose?: "user" | "administrative";
|
|
12889
12889
|
};
|
|
12890
12890
|
type GetEnvironmentByIdApiResponse = {
|
|
12891
12891
|
/** Zero-based page index returned in this response. */
|
|
@@ -12916,16 +12916,16 @@ type GetEnvironmentByIdApiResponse = {
|
|
|
12916
12916
|
updatedAt?: string;
|
|
12917
12917
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
12918
12918
|
deletedAt?: string | null;
|
|
12919
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
12919
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
12920
12920
|
|
|
12921
12921
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
12922
12922
|
|
|
12923
12923
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
12924
12924
|
|
|
12925
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
12925
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
12926
12926
|
|
|
12927
12927
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
12928
|
-
purpose?: "user" | "administrative"
|
|
12928
|
+
purpose?: "user" | "administrative";
|
|
12929
12929
|
}[];
|
|
12930
12930
|
};
|
|
12931
12931
|
type GetEnvironmentByIdApiArg = {
|
|
@@ -12963,16 +12963,16 @@ type UpdateEnvironmentApiResponse = {
|
|
|
12963
12963
|
updatedAt?: string;
|
|
12964
12964
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
12965
12965
|
deletedAt?: string | null;
|
|
12966
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
12966
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
12967
12967
|
|
|
12968
12968
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
12969
12969
|
|
|
12970
12970
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
12971
12971
|
|
|
12972
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
12972
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
12973
12973
|
|
|
12974
12974
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
12975
|
-
purpose?: "user" | "administrative"
|
|
12975
|
+
purpose?: "user" | "administrative";
|
|
12976
12976
|
}[];
|
|
12977
12977
|
};
|
|
12978
12978
|
type UpdateEnvironmentApiArg = {
|
|
@@ -12990,8 +12990,8 @@ type UpdateEnvironmentApiArg = {
|
|
|
12990
12990
|
metadata?: {
|
|
12991
12991
|
[key: string]: any;
|
|
12992
12992
|
};
|
|
12993
|
-
/** The
|
|
12994
|
-
purpose?: "user"
|
|
12993
|
+
/** The purpose a client may give an environment on create or update: `user` (an ordinary environment). Profiles are not environments; they are their own construct at `/api/profiles`, assigned to workspaces. Omitted means `user` on create and unchanged on update. A server refuses any other value with 400, and never lets this field change an environment that already carries a privileged purpose. */
|
|
12994
|
+
purpose?: "user";
|
|
12995
12995
|
};
|
|
12996
12996
|
};
|
|
12997
12997
|
type DeleteEnvironmentApiResponse = unknown;
|
|
@@ -14235,9 +14235,10 @@ type ListLedgerEntriesApiResponse = {
|
|
|
14235
14235
|
entryKey: string;
|
|
14236
14236
|
/** Entry value, stored as a JSON blob. */
|
|
14237
14237
|
value?: object;
|
|
14238
|
-
/**
|
|
14239
|
-
|
|
14240
|
-
|
|
14238
|
+
/** ID of the connection that holds the entry, if any. Set only by claim-if-absent and never changed afterwards. References a connection (`connections.id`); a claim held by a connection that is later deleted is released, so the key may be claimed again. Omitted when the entry is unclaimed.
|
|
14239
|
+
*/
|
|
14240
|
+
claimedByConnectionId?: string;
|
|
14241
|
+
/** Time the current or most recent claim was taken. Set only by claim-if-absent; null when the entry was never claimed. An entry whose claimedByConnectionId is omitted is unclaimed whatever this holds. */
|
|
14241
14242
|
claimedAt?: string | null;
|
|
14242
14243
|
/** Timestamp of ledger entry creation. */
|
|
14243
14244
|
createdAt: string;
|
|
@@ -14268,9 +14269,10 @@ type RecordLedgerEntryApiResponse = {
|
|
|
14268
14269
|
entryKey: string;
|
|
14269
14270
|
/** Entry value, stored as a JSON blob. */
|
|
14270
14271
|
value?: object;
|
|
14271
|
-
/**
|
|
14272
|
-
|
|
14273
|
-
|
|
14272
|
+
/** ID of the connection that holds the entry, if any. Set only by claim-if-absent and never changed afterwards. References a connection (`connections.id`); a claim held by a connection that is later deleted is released, so the key may be claimed again. Omitted when the entry is unclaimed.
|
|
14273
|
+
*/
|
|
14274
|
+
claimedByConnectionId?: string;
|
|
14275
|
+
/** Time the current or most recent claim was taken. Set only by claim-if-absent; null when the entry was never claimed. An entry whose claimedByConnectionId is omitted is unclaimed whatever this holds. */
|
|
14274
14276
|
claimedAt?: string | null;
|
|
14275
14277
|
/** Timestamp of ledger entry creation. */
|
|
14276
14278
|
createdAt: string;
|
|
@@ -14287,9 +14289,10 @@ type RecordLedgerEntryApiResponse = {
|
|
|
14287
14289
|
entryKey: string;
|
|
14288
14290
|
/** Entry value, stored as a JSON blob. */
|
|
14289
14291
|
value?: object;
|
|
14290
|
-
/**
|
|
14291
|
-
|
|
14292
|
-
|
|
14292
|
+
/** ID of the connection that holds the entry, if any. Set only by claim-if-absent and never changed afterwards. References a connection (`connections.id`); a claim held by a connection that is later deleted is released, so the key may be claimed again. Omitted when the entry is unclaimed.
|
|
14293
|
+
*/
|
|
14294
|
+
claimedByConnectionId?: string;
|
|
14295
|
+
/** Time the current or most recent claim was taken. Set only by claim-if-absent; null when the entry was never claimed. An entry whose claimedByConnectionId is omitted is unclaimed whatever this holds. */
|
|
14293
14296
|
claimedAt?: string | null;
|
|
14294
14297
|
/** Timestamp of ledger entry creation. */
|
|
14295
14298
|
createdAt: string;
|
|
@@ -14317,9 +14320,10 @@ type ClaimLedgerEntryApiResponse = {
|
|
|
14317
14320
|
entryKey: string;
|
|
14318
14321
|
/** Entry value, stored as a JSON blob. */
|
|
14319
14322
|
value?: object;
|
|
14320
|
-
/**
|
|
14321
|
-
|
|
14322
|
-
|
|
14323
|
+
/** ID of the connection that holds the entry, if any. Set only by claim-if-absent and never changed afterwards. References a connection (`connections.id`); a claim held by a connection that is later deleted is released, so the key may be claimed again. Omitted when the entry is unclaimed.
|
|
14324
|
+
*/
|
|
14325
|
+
claimedByConnectionId?: string;
|
|
14326
|
+
/** Time the current or most recent claim was taken. Set only by claim-if-absent; null when the entry was never claimed. An entry whose claimedByConnectionId is omitted is unclaimed whatever this holds. */
|
|
14323
14327
|
claimedAt?: string | null;
|
|
14324
14328
|
/** Timestamp of ledger entry creation. */
|
|
14325
14329
|
createdAt: string;
|
|
@@ -14336,9 +14340,10 @@ type ClaimLedgerEntryApiResponse = {
|
|
|
14336
14340
|
entryKey: string;
|
|
14337
14341
|
/** Entry value, stored as a JSON blob. */
|
|
14338
14342
|
value?: object;
|
|
14339
|
-
/**
|
|
14340
|
-
|
|
14341
|
-
|
|
14343
|
+
/** ID of the connection that holds the entry, if any. Set only by claim-if-absent and never changed afterwards. References a connection (`connections.id`); a claim held by a connection that is later deleted is released, so the key may be claimed again. Omitted when the entry is unclaimed.
|
|
14344
|
+
*/
|
|
14345
|
+
claimedByConnectionId?: string;
|
|
14346
|
+
/** Time the current or most recent claim was taken. Set only by claim-if-absent; null when the entry was never claimed. An entry whose claimedByConnectionId is omitted is unclaimed whatever this holds. */
|
|
14342
14347
|
claimedAt?: string | null;
|
|
14343
14348
|
/** Timestamp of ledger entry creation. */
|
|
14344
14349
|
createdAt: string;
|
|
@@ -14351,8 +14356,9 @@ type ClaimLedgerEntryApiArg = {
|
|
|
14351
14356
|
body: {
|
|
14352
14357
|
/** Key to claim. */
|
|
14353
14358
|
entryKey: string;
|
|
14354
|
-
/**
|
|
14355
|
-
|
|
14359
|
+
/** ID of the connection taking the key: the caller's own live connection in the session organization (for example the connection a desktop client registered for its machine).
|
|
14360
|
+
*/
|
|
14361
|
+
connectionId: string;
|
|
14356
14362
|
/** Value stored when the claim creates the entry; ignored when the entry already exists. */
|
|
14357
14363
|
value?: object;
|
|
14358
14364
|
};
|
|
@@ -14368,9 +14374,10 @@ type GetLedgerEntryApiResponse = {
|
|
|
14368
14374
|
entryKey: string;
|
|
14369
14375
|
/** Entry value, stored as a JSON blob. */
|
|
14370
14376
|
value?: object;
|
|
14371
|
-
/**
|
|
14372
|
-
|
|
14373
|
-
|
|
14377
|
+
/** ID of the connection that holds the entry, if any. Set only by claim-if-absent and never changed afterwards. References a connection (`connections.id`); a claim held by a connection that is later deleted is released, so the key may be claimed again. Omitted when the entry is unclaimed.
|
|
14378
|
+
*/
|
|
14379
|
+
claimedByConnectionId?: string;
|
|
14380
|
+
/** Time the current or most recent claim was taken. Set only by claim-if-absent; null when the entry was never claimed. An entry whose claimedByConnectionId is omitted is unclaimed whatever this holds. */
|
|
14374
14381
|
claimedAt?: string | null;
|
|
14375
14382
|
/** Timestamp of ledger entry creation. */
|
|
14376
14383
|
createdAt: string;
|
|
@@ -15406,16 +15413,16 @@ type GetProfileConnectionsApiResponse = {
|
|
|
15406
15413
|
updatedAt?: string;
|
|
15407
15414
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
15408
15415
|
deletedAt?: string | null;
|
|
15409
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
15416
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
15410
15417
|
|
|
15411
15418
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
15412
15419
|
|
|
15413
15420
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
15414
15421
|
|
|
15415
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
15422
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
15416
15423
|
|
|
15417
15424
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
15418
|
-
purpose?: "user" | "administrative"
|
|
15425
|
+
purpose?: "user" | "administrative";
|
|
15419
15426
|
}[];
|
|
15420
15427
|
/** Specifies the version of the schema used for the definition. */
|
|
15421
15428
|
schemaVersion: string;
|
|
@@ -17592,16 +17599,16 @@ type GetEnvironmentsOfWorkspaceApiResponse = {
|
|
|
17592
17599
|
updatedAt?: string;
|
|
17593
17600
|
/** Timestamp when the environment was soft deleted. Null while the environment remains active. */
|
|
17594
17601
|
deletedAt?: string | null;
|
|
17595
|
-
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
17602
|
+
/** What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
17596
17603
|
|
|
17597
17604
|
Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
17598
17605
|
|
|
17599
17606
|
At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
17600
17607
|
|
|
17601
|
-
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
17608
|
+
Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
17602
17609
|
|
|
17603
17610
|
The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md. */
|
|
17604
|
-
purpose?: "user" | "administrative"
|
|
17611
|
+
purpose?: "user" | "administrative";
|
|
17605
17612
|
}[];
|
|
17606
17613
|
};
|
|
17607
17614
|
type GetEnvironmentsOfWorkspaceApiArg = {
|
|
@@ -720,18 +720,18 @@ export interface operations {
|
|
|
720
720
|
*/
|
|
721
721
|
deletedAt?: string | null;
|
|
722
722
|
/**
|
|
723
|
-
* @description What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust.
|
|
723
|
+
* @description What the environment exists for. `user` is an ordinary environment that people create to logically group Connections and their Credentials. `administrative` designates an environment the platform itself provisions to hold organization-level configuration, and which resolvers of that configuration therefore trust. Profiles are not environments: they are their own construct (`schemas/constructs/v1beta3/profile`, served at `/api/profiles` and assigned to workspaces under `/api/workspaces/{workspaceId}/profiles`).
|
|
724
724
|
*
|
|
725
725
|
* Absent means `user`. Nothing may read an unset or unrecognised value as administrative: test for the administrative value explicitly rather than for "not user", so the property fails closed.
|
|
726
726
|
*
|
|
727
727
|
* At most one live environment per organization may carry any single privileged purpose - `administrative`, and each privileged value a later version adds. Name those values explicitly wherever the rule is enforced, including the database index predicate: a "not `user`" test also matches the empty value that unmigrated rows and un-normalised writes read back as, which means ordinary. A resolver that selects an environment by purpose MUST fail closed when more than one live row matches: return an error rather than whichever row the database happened to return first.
|
|
728
728
|
*
|
|
729
|
-
* Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged
|
|
729
|
+
* Privileged values are server-owned and never client-settable. `EnvironmentPayload`, which every environment POST and PUT requestBody references, accepts only the non-privileged value `user`, and the create-or-edit form has no field for it, so the environment create and update endpoints cannot designate an environment administrative. That restriction is a codegen guarantee, never access control: the registrant connection inlines the full environment entity, so `registerRegistryComponent` and `registerRegistryRelationship` do carry `purpose` in a request type and consumers MUST refuse it on input there too. Whatever surface a value arrives on, every consumer MUST assign this property only from server-side provisioning or a data migration. Permission to create an environment does not confer the ability to make one administrative.
|
|
730
730
|
*
|
|
731
731
|
* The database index that enforces the uniqueness invariant, the migration path for environments that are administrative by naming convention today, and each consumer's obligations are specified in https://github.com/meshery/schemas/blob/master/docs/environment-purpose-contract.md.
|
|
732
732
|
* @enum {string}
|
|
733
733
|
*/
|
|
734
|
-
purpose?: "user" | "administrative"
|
|
734
|
+
purpose?: "user" | "administrative";
|
|
735
735
|
};
|
|
736
736
|
};
|
|
737
737
|
};
|