@equinor/fusion-services 0.2.0

package/dist/types/roles/endpoints/system-access-role.delete.d.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod, ClientMethodType, ExtractApiVersion, FilterAllowedApiVersions, VersionedArgs, VersionedResponse } from '../types';
+import { ApiVersion } from '../static';
+/** Concrete API versions this operation publishes. */
+type AvailableVersions = ApiVersion.v1;
+/**
+ * API version identifiers `deleteSystemAccessRole` accepts for
+ * `DELETE /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}`.
+ *
+ * Roles V2 publishes version 1.0 of this operation, nameable as `'v1'`, `'1.0'`, or
+ * `ApiVersion.v1`. All three resolve to the same contract entry, so all three infer the same
+ * {@link DeleteSystemAccessRoleArg} and {@link DeleteSystemAccessRoleResponse}.
+ */
+type DeleteSystemAccessRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `deleteSystemAccessRole`, implementing
+ * `DELETE /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}`.
+ *
+ * Each concrete {@link ApiVersion} maps to the argument and response schemas that
+ * version publishes, so the version a caller passes is the single discriminator
+ * for the request shape, the request path, and the response shape.
+ */
+declare const VersionContract: {
+    readonly "1.0": {
+        /** Arguments accepted by version 1.0 of this operation. */
+        readonly args: z.ZodObject<{
+            systemIdentifier: z.ZodString;
+            accessRoleIdentifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0. The operation answers `204 No Content`. */
+        readonly response: z.ZodVoid;
+    };
+};
+/**
+ * Response body `deleteSystemAccessRole` resolves for the selected API version.
+ *
+ * Version 1.0 answers `204 No Content` without a body, so the type resolves to `void`.
+ */
+type DeleteSystemAccessRoleResponse<TVersion extends DeleteSystemAccessRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `deleteSystemAccessRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifiers `systemIdentifier`, `accessRoleIdentifier`.
+ *
+ * The value is parsed by the version's Zod argument schema before the request path is built, so
+ * defaults and range checks apply up front.
+ */
+type DeleteSystemAccessRoleArg<TVersion extends DeleteSystemAccessRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `deleteSystemAccessRole` hands back once the request runs, for the selected API version
+ * and client method.
+ *
+ * `'json'` gives `Promise<DeleteSystemAccessRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<DeleteSystemAccessRoleResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type DeleteSystemAccessRoleResult<TVersion extends DeleteSystemAccessRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<DeleteSystemAccessRoleResponse<TVersion>>[TMethod];
+/**
+ * Deletes one access role owned by a system.
+ *
+ * Roles V2 operation: `DELETE /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}`
+ * — "Delete an access role from a system."
+ *
+ * Curried in two stages: `deleteSystemAccessRole(version, client, method)` binds the API
+ * version, the `IHttpClient` that reaches the Roles service, and the execution method —
+ * `'json'` for a promise, `'json$'` for an observable stream. The returned function takes
+ * {@link DeleteSystemAccessRoleArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link DeleteSystemAccessRoleResult}.
+ *
+ * The version argument is the single discriminator: `'v1'` — equivalently `'1.0'` or
+ * `ApiVersion.v1` — selects the version-1.0 argument schema, expects the empty success body,
+ * and sends `api-version=1.0` on the request.
+ *
+ * Destructive: it removes the access role permanently, and the deletion cannot be undone
+ * through this API. Roles V2 answers `204 No Content` with no body, so the resolved value is
+ * `void`. The contract declares `403 Forbidden` for callers the Roles service does not
+ * authorise for this operation.
+ *
+ * @template TVersion - Roles API version identifier: `'v1'`, `'1.0'`, or `ApiVersion.v1`.
+ * @template TMethod - Execution method: `'json'` for a promise, `'json$'` for an observable.
+ * @param version - API version selecting the request path, the argument schema, and the
+ * response schema.
+ * @param client - HTTP client that executes the request against the Roles service.
+ * @param method - Execution method, defaulting to `'json'`.
+ * @returns A request function taking {@link DeleteSystemAccessRoleArg} and an optional
+ * `ClientRequestInit`, returning {@link DeleteSystemAccessRoleResult}.
+ * @throws {Error} When `version` names an API version this operation does not publish. The
+ * check runs while binding, before the HTTP client is used.
+ * @throws {z.ZodError} From the returned function, when the arguments fail this version's
+ * argument schema or the response body fails its response schema.
+ *
+ * @example
+ * ```ts
+ * import { deleteSystemAccessRole } from '@equinor/fusion-services/roles';
+ *
+ * await deleteSystemAccessRole('v1', httpClient)({
+ *   systemIdentifier: 'fusion-core',
+ *   accessRoleIdentifier: 'writer',
+ * });
+ * ```
+ */
+declare const deleteSystemAccessRole: <TVersion extends DeleteSystemAccessRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: DeleteSystemAccessRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, DeleteSystemAccessRoleResponse<ExtractApiVersion<TVersion>>>) => DeleteSystemAccessRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type DeleteSystemAccessRoleArg, type DeleteSystemAccessRoleResponse, type DeleteSystemAccessRoleResult, type DeleteSystemAccessRoleVersion, deleteSystemAccessRole, };

package/dist/types/roles/endpoints/system-access-role.get.d.ts

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod, ClientMethodType, ExtractApiVersion, FilterAllowedApiVersions, VersionedArgs, VersionedResponse } from '../types';
+import { ApiVersion } from '../static';
+/** Concrete API versions this operation publishes. */
+type AvailableVersions = ApiVersion.v1;
+/**
+ * API version identifiers `getSystemAccessRole` accepts for
+ * `GET /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}`.
+ *
+ * Roles V2 publishes version 1.0 of this operation, nameable as `'v1'`, `'1.0'`, or
+ * `ApiVersion.v1`. All three resolve to the same contract entry, so all three infer the same
+ * {@link GetSystemAccessRoleArg} and {@link GetSystemAccessRoleResponse}.
+ */
+type GetSystemAccessRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `getSystemAccessRole`, implementing
+ * `GET /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}`.
+ *
+ * Each concrete {@link ApiVersion} maps to the argument and response schemas that
+ * version publishes, so the version a caller passes is the single discriminator
+ * for the request shape, the request path, and the response shape.
+ */
+declare const VersionContract: {
+    readonly "1.0": {
+        /** Arguments accepted by version 1.0 of this operation. */
+        readonly args: z.ZodObject<{
+            systemIdentifier: z.ZodString;
+            accessRoleIdentifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            scopeType: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `getSystemAccessRole` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiAccessRoleV1`, inferred from `ApiAccessRoleSchemaV1` — the very
+ * schema that validates the `200 OK` body at runtime.
+ */
+type GetSystemAccessRoleResponse<TVersion extends GetSystemAccessRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `getSystemAccessRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifiers `systemIdentifier`, `accessRoleIdentifier`.
+ *
+ * The value is parsed by the version's Zod argument schema before the request path is built, so
+ * defaults and range checks apply up front.
+ */
+type GetSystemAccessRoleArg<TVersion extends GetSystemAccessRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `getSystemAccessRole` hands back once the request runs, for the selected API version and
+ * client method.
+ *
+ * `'json'` gives `Promise<GetSystemAccessRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<GetSystemAccessRoleResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type GetSystemAccessRoleResult<TVersion extends GetSystemAccessRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<GetSystemAccessRoleResponse<TVersion>>[TMethod];
+/**
+ * Fetches one access role owned by a system, by its UUID or unique name.
+ *
+ * Roles V2 operation: `GET /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}` —
+ * "Get an access role by identifier."
+ *
+ * Curried in two stages: `getSystemAccessRole(version, client, method)` binds the API version,
+ * the `IHttpClient` that reaches the Roles service, and the execution method — `'json'` for a
+ * promise, `'json$'` for an observable stream. The returned function takes
+ * {@link GetSystemAccessRoleArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link GetSystemAccessRoleResult}.
+ *
+ * The version argument is the single discriminator: `'v1'` — equivalently `'1.0'` or
+ * `ApiVersion.v1` — selects the version-1.0 argument schema, validates the response with
+ * `ApiAccessRoleSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiAccessRoleV1`.
+ *
+ * @template TVersion - Roles API version identifier: `'v1'`, `'1.0'`, or `ApiVersion.v1`.
+ * @template TMethod - Execution method: `'json'` for a promise, `'json$'` for an observable.
+ * @param version - API version selecting the request path, the argument schema, and the
+ * response schema.
+ * @param client - HTTP client that executes the request against the Roles service.
+ * @param method - Execution method, defaulting to `'json'`.
+ * @returns A request function taking {@link GetSystemAccessRoleArg} and an optional
+ * `ClientRequestInit`, returning {@link GetSystemAccessRoleResult}.
+ * @throws {Error} When `version` names an API version this operation does not publish. The
+ * check runs while binding, before the HTTP client is used.
+ * @throws {z.ZodError} From the returned function, when the arguments fail this version's
+ * argument schema or the response body fails its response schema.
+ *
+ * @example
+ * ```ts
+ * import { getSystemAccessRole } from '@equinor/fusion-services/roles';
+ *
+ * const accessRole = await getSystemAccessRole('v1', httpClient)({
+ *   systemIdentifier: 'fusion-core',
+ *   accessRoleIdentifier: 'writer',
+ * });
+ * ```
+ */
+declare const getSystemAccessRole: <TVersion extends GetSystemAccessRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: GetSystemAccessRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, GetSystemAccessRoleResponse<ExtractApiVersion<TVersion>>>) => GetSystemAccessRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type GetSystemAccessRoleArg, type GetSystemAccessRoleResponse, type GetSystemAccessRoleResult, type GetSystemAccessRoleVersion, getSystemAccessRole, };

package/dist/types/roles/endpoints/system-access-role.patch.d.ts

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod, ClientMethodType, ExtractApiVersion, FilterAllowedApiVersions, VersionedArgs, VersionedResponse } from '../types';
+import { ApiVersion } from '../static';
+/** Concrete API versions this operation publishes. */
+type AvailableVersions = ApiVersion.v1;
+/**
+ * API version identifiers `updateSystemAccessRole` accepts for
+ * `PATCH /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}`.
+ *
+ * Roles V2 publishes version 1.0 of this operation, nameable as `'v1'`, `'1.0'`, or
+ * `ApiVersion.v1`. All three resolve to the same contract entry, so all three infer the same
+ * {@link UpdateSystemAccessRoleArg} and {@link UpdateSystemAccessRoleResponse}.
+ */
+type UpdateSystemAccessRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `updateSystemAccessRole`, implementing
+ * `PATCH /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}`.
+ *
+ * Each concrete {@link ApiVersion} maps to the argument and response schemas that
+ * version publishes, so the version a caller passes is the single discriminator
+ * for the request shape, the request path, and the response shape.
+ */
+declare const VersionContract: {
+    readonly "1.0": {
+        /** Arguments accepted by version 1.0 of this operation. */
+        readonly args: z.ZodObject<{
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            systemIdentifier: z.ZodString;
+            accessRoleIdentifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            scopeType: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `updateSystemAccessRole` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiAccessRoleV1`, inferred from `ApiAccessRoleSchemaV1` — the very
+ * schema that validates the `200 OK` body at runtime.
+ */
+type UpdateSystemAccessRoleResponse<TVersion extends UpdateSystemAccessRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `updateSystemAccessRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifiers `systemIdentifier`, `accessRoleIdentifier`, and the
+ * request body fields of `UpdateAccessRoleRequestV1`.
+ *
+ * Path identifiers and body fields share one flat object; the endpoint separates them when it
+ * builds the request. The value is parsed by the version's Zod argument schema before anything
+ * is sent.
+ */
+type UpdateSystemAccessRoleArg<TVersion extends UpdateSystemAccessRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `updateSystemAccessRole` hands back once the request runs, for the selected API version
+ * and client method.
+ *
+ * `'json'` gives `Promise<UpdateSystemAccessRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<UpdateSystemAccessRoleResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type UpdateSystemAccessRoleResult<TVersion extends UpdateSystemAccessRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<UpdateSystemAccessRoleResponse<TVersion>>[TMethod];
+/**
+ * Updates the description of a system access role.
+ *
+ * Roles V2 operation: `PATCH /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}` —
+ * "Update an access role for a system."
+ *
+ * Curried in two stages: `updateSystemAccessRole(version, client, method)` binds the API
+ * version, the `IHttpClient` that reaches the Roles service, and the execution method —
+ * `'json'` for a promise, `'json$'` for an observable stream. The returned function takes
+ * {@link UpdateSystemAccessRoleArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link UpdateSystemAccessRoleResult}.
+ *
+ * The version argument is the single discriminator: `'v1'` — equivalently `'1.0'` or
+ * `ApiVersion.v1` — selects the version-1.0 argument schema, validates the response with
+ * `ApiAccessRoleSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiAccessRoleV1`. Fields left out of the
+ * arguments are not sent, so they keep their stored values. The contract declares `403
+ * Forbidden` for callers the Roles service does not authorise for this operation.
+ *
+ * @template TVersion - Roles API version identifier: `'v1'`, `'1.0'`, or `ApiVersion.v1`.
+ * @template TMethod - Execution method: `'json'` for a promise, `'json$'` for an observable.
+ * @param version - API version selecting the request path, the argument schema, and the
+ * response schema.
+ * @param client - HTTP client that executes the request against the Roles service.
+ * @param method - Execution method, defaulting to `'json'`.
+ * @returns A request function taking {@link UpdateSystemAccessRoleArg} and an optional
+ * `ClientRequestInit`, returning {@link UpdateSystemAccessRoleResult}.
+ * @throws {Error} When `version` names an API version this operation does not publish. The
+ * check runs while binding, before the HTTP client is used.
+ * @throws {z.ZodError} From the returned function, when the arguments fail this version's
+ * argument schema or the response body fails its response schema.
+ *
+ * @example
+ * ```ts
+ * import { updateSystemAccessRole } from '@equinor/fusion-services/roles';
+ *
+ * const accessRole = await updateSystemAccessRole('v1', httpClient)({
+ *   systemIdentifier: 'fusion-core',
+ *   accessRoleIdentifier: 'writer',
+ *   description: 'Write access',
+ * });
+ * ```
+ */
+declare const updateSystemAccessRole: <TVersion extends UpdateSystemAccessRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: UpdateSystemAccessRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, UpdateSystemAccessRoleResponse<ExtractApiVersion<TVersion>>>) => UpdateSystemAccessRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type UpdateSystemAccessRoleArg, type UpdateSystemAccessRoleResponse, type UpdateSystemAccessRoleResult, type UpdateSystemAccessRoleVersion, updateSystemAccessRole, };

package/dist/types/roles/endpoints/system-access-roles.get.d.ts

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod, ClientMethodType, ExtractApiVersion, FilterAllowedApiVersions, VersionedArgs, VersionedResponse } from '../types';
+import { ApiVersion } from '../static';
+/** Concrete API versions this operation publishes. */
+type AvailableVersions = ApiVersion.v1;
+/**
+ * API version identifiers `listSystemAccessRoles` accepts for
+ * `GET /systems/{systemIdentifier}/access-roles`.
+ *
+ * Roles V2 publishes version 1.0 of this operation, nameable as `'v1'`, `'1.0'`, or
+ * `ApiVersion.v1`. All three resolve to the same contract entry, so all three infer the same
+ * {@link ListSystemAccessRolesArg} and {@link ListSystemAccessRolesResponse}.
+ */
+type ListSystemAccessRolesVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listSystemAccessRoles`, implementing
+ * `GET /systems/{systemIdentifier}/access-roles`.
+ *
+ * Each concrete {@link ApiVersion} maps to the argument and response schemas that
+ * version publishes, so the version a caller passes is the single discriminator
+ * for the request shape, the request path, and the response shape.
+ */
+declare const VersionContract: {
+    readonly "1.0": {
+        /** Arguments accepted by version 1.0 of this operation. */
+        readonly args: z.ZodObject<{
+            systemIdentifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            scopeType: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    };
+};
+/**
+ * Response body `listSystemAccessRoles` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiAccessRoleV1[]`, inferred from `z.array(ApiAccessRoleSchemaV1)` —
+ * the very schema that validates the `200 OK` body at runtime.
+ */
+type ListSystemAccessRolesResponse<TVersion extends ListSystemAccessRolesVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listSystemAccessRoles` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `systemIdentifier`.
+ *
+ * The value is parsed by the version's Zod argument schema before the request path is built, so
+ * defaults and range checks apply up front.
+ */
+type ListSystemAccessRolesArg<TVersion extends ListSystemAccessRolesVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listSystemAccessRoles` hands back once the request runs, for the selected API version
+ * and client method.
+ *
+ * `'json'` gives `Promise<ListSystemAccessRolesResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<ListSystemAccessRolesResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type ListSystemAccessRolesResult<TVersion extends ListSystemAccessRolesVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListSystemAccessRolesResponse<TVersion>>[TMethod];
+/**
+ * Lists the access roles owned by one registered system.
+ *
+ * Roles V2 operation: `GET /systems/{systemIdentifier}/access-roles` — "Get all access roles
+ * for a system."
+ *
+ * Curried in two stages: `listSystemAccessRoles(version, client, method)` binds the API
+ * version, the `IHttpClient` that reaches the Roles service, and the execution method —
+ * `'json'` for a promise, `'json$'` for an observable stream. The returned function takes
+ * {@link ListSystemAccessRolesArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link ListSystemAccessRolesResult}.
+ *
+ * The version argument is the single discriminator: `'v1'` — equivalently `'1.0'` or
+ * `ApiVersion.v1` — selects the version-1.0 argument schema, validates the response with
+ * `z.array(ApiAccessRoleSchemaV1)`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiAccessRoleV1[]`.
+ *
+ * @template TVersion - Roles API version identifier: `'v1'`, `'1.0'`, or `ApiVersion.v1`.
+ * @template TMethod - Execution method: `'json'` for a promise, `'json$'` for an observable.
+ * @param version - API version selecting the request path, the argument schema, and the
+ * response schema.
+ * @param client - HTTP client that executes the request against the Roles service.
+ * @param method - Execution method, defaulting to `'json'`.
+ * @returns A request function taking {@link ListSystemAccessRolesArg} and an optional
+ * `ClientRequestInit`, returning {@link ListSystemAccessRolesResult}.
+ * @throws {Error} When `version` names an API version this operation does not publish. The
+ * check runs while binding, before the HTTP client is used.
+ * @throws {z.ZodError} From the returned function, when the arguments fail this version's
+ * argument schema or the response body fails its response schema.
+ *
+ * @example
+ * ```ts
+ * import { listSystemAccessRoles } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listSystemAccessRoles('v1', httpClient)({
+ *   systemIdentifier: 'fusion-core',
+ * });
+ * ```
+ */
+declare const listSystemAccessRoles: <TVersion extends ListSystemAccessRolesVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: ListSystemAccessRolesArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListSystemAccessRolesResponse<ExtractApiVersion<TVersion>>>) => ListSystemAccessRolesResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListSystemAccessRolesArg, type ListSystemAccessRolesResponse, type ListSystemAccessRolesResult, type ListSystemAccessRolesVersion, listSystemAccessRoles, };

package/dist/types/roles/endpoints/system-access-roles.post.d.ts

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod, ClientMethodType, ExtractApiVersion, FilterAllowedApiVersions, VersionedArgs, VersionedResponse } from '../types';
+import { ApiVersion } from '../static';
+/** Concrete API versions this operation publishes. */
+type AvailableVersions = ApiVersion.v1;
+/**
+ * API version identifiers `createSystemAccessRole` accepts for
+ * `POST /systems/{systemIdentifier}/access-roles`.
+ *
+ * Roles V2 publishes version 1.0 of this operation, nameable as `'v1'`, `'1.0'`, or
+ * `ApiVersion.v1`. All three resolve to the same contract entry, so all three infer the same
+ * {@link CreateSystemAccessRoleArg} and {@link CreateSystemAccessRoleResponse}.
+ */
+type CreateSystemAccessRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `createSystemAccessRole`, implementing
+ * `POST /systems/{systemIdentifier}/access-roles`.
+ *
+ * Each concrete {@link ApiVersion} maps to the argument and response schemas that
+ * version publishes, so the version a caller passes is the single discriminator
+ * for the request shape, the request path, and the response shape.
+ */
+declare const VersionContract: {
+    readonly "1.0": {
+        /** Arguments accepted by version 1.0 of this operation. */
+        readonly args: z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            scopeTypeIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            systemIdentifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            scopeType: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `createSystemAccessRole` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiAccessRoleV1`, inferred from `ApiAccessRoleSchemaV1` — the very
+ * schema that validates the `201 Created` body at runtime.
+ */
+type CreateSystemAccessRoleResponse<TVersion extends CreateSystemAccessRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `createSystemAccessRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `systemIdentifier`, and the request body fields of
+ * `CreateAccessRoleRequestV1`.
+ *
+ * Path identifiers and body fields share one flat object; the endpoint separates them when it
+ * builds the request. The value is parsed by the version's Zod argument schema before anything
+ * is sent.
+ */
+type CreateSystemAccessRoleArg<TVersion extends CreateSystemAccessRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `createSystemAccessRole` hands back once the request runs, for the selected API version
+ * and client method.
+ *
+ * `'json'` gives `Promise<CreateSystemAccessRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<CreateSystemAccessRoleResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type CreateSystemAccessRoleResult<TVersion extends CreateSystemAccessRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<CreateSystemAccessRoleResponse<TVersion>>[TMethod];
+/**
+ * Creates an access role owned by a registered system.
+ *
+ * Roles V2 operation: `POST /systems/{systemIdentifier}/access-roles` — "Create an access role
+ * for a system."
+ *
+ * Curried in two stages: `createSystemAccessRole(version, client, method)` binds the API
+ * version, the `IHttpClient` that reaches the Roles service, and the execution method —
+ * `'json'` for a promise, `'json$'` for an observable stream. The returned function takes
+ * {@link CreateSystemAccessRoleArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link CreateSystemAccessRoleResult}.
+ *
+ * The version argument is the single discriminator: `'v1'` — equivalently `'1.0'` or
+ * `ApiVersion.v1` — selects the version-1.0 argument schema, validates the response with
+ * `ApiAccessRoleSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `201 Created`; the body is typed `ApiAccessRoleV1`. The contract declares
+ * `403 Forbidden` for callers the Roles service does not authorise for this operation.
+ *
+ * @template TVersion - Roles API version identifier: `'v1'`, `'1.0'`, or `ApiVersion.v1`.
+ * @template TMethod - Execution method: `'json'` for a promise, `'json$'` for an observable.
+ * @param version - API version selecting the request path, the argument schema, and the
+ * response schema.
+ * @param client - HTTP client that executes the request against the Roles service.
+ * @param method - Execution method, defaulting to `'json'`.
+ * @returns A request function taking {@link CreateSystemAccessRoleArg} and an optional
+ * `ClientRequestInit`, returning {@link CreateSystemAccessRoleResult}.
+ * @throws {Error} When `version` names an API version this operation does not publish. The
+ * check runs while binding, before the HTTP client is used.
+ * @throws {z.ZodError} From the returned function, when the arguments fail this version's
+ * argument schema or the response body fails its response schema.
+ *
+ * @example
+ * ```ts
+ * import { createSystemAccessRole } from '@equinor/fusion-services/roles';
+ *
+ * const accessRole = await createSystemAccessRole('v1', httpClient)({
+ *   systemIdentifier: 'fusion-core',
+ *   name: 'writer',
+ *   description: 'Write access',
+ * });
+ * ```
+ */
+declare const createSystemAccessRole: <TVersion extends CreateSystemAccessRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: CreateSystemAccessRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, CreateSystemAccessRoleResponse<ExtractApiVersion<TVersion>>>) => CreateSystemAccessRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type CreateSystemAccessRoleArg, type CreateSystemAccessRoleResponse, type CreateSystemAccessRoleResult, type CreateSystemAccessRoleVersion, createSystemAccessRole, };

package/dist/types/roles/endpoints/system.delete.d.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod, ClientMethodType, ExtractApiVersion, FilterAllowedApiVersions, VersionedArgs, VersionedResponse } from '../types';
+import { ApiVersion } from '../static';
+/** Concrete API versions this operation publishes. */
+type AvailableVersions = ApiVersion.v1;
+/**
+ * API version identifiers `deleteSystem` accepts for `DELETE /systems/{systemIdentifier}`.
+ *
+ * Roles V2 publishes version 1.0 of this operation, nameable as `'v1'`, `'1.0'`, or
+ * `ApiVersion.v1`. All three resolve to the same contract entry, so all three infer the same
+ * {@link DeleteSystemArg} and {@link DeleteSystemResponse}.
+ */
+type DeleteSystemVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `deleteSystem`, implementing `DELETE /systems/{systemIdentifier}`.
+ *
+ * Each concrete {@link ApiVersion} maps to the argument and response schemas that
+ * version publishes, so the version a caller passes is the single discriminator
+ * for the request shape, the request path, and the response shape.
+ */
+declare const VersionContract: {
+    readonly "1.0": {
+        /** Arguments accepted by version 1.0 of this operation. */
+        readonly args: z.ZodObject<{
+            systemIdentifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0. The operation answers `204 No Content`. */
+        readonly response: z.ZodVoid;
+    };
+};
+/**
+ * Response body `deleteSystem` resolves for the selected API version.
+ *
+ * Version 1.0 answers `204 No Content` without a body, so the type resolves to `void`.
+ */
+type DeleteSystemResponse<TVersion extends DeleteSystemVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `deleteSystem` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `systemIdentifier`.
+ *
+ * The value is parsed by the version's Zod argument schema before the request path is built, so
+ * defaults and range checks apply up front.
+ */
+type DeleteSystemArg<TVersion extends DeleteSystemVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `deleteSystem` hands back once the request runs, for the selected API version and client
+ * method.
+ *
+ * `'json'` gives `Promise<DeleteSystemResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<DeleteSystemResponse<TVersion>>`, so promise and observable callers share one
+ * response type.
+ */
+type DeleteSystemResult<TVersion extends DeleteSystemVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<DeleteSystemResponse<TVersion>>[TMethod];
+/**
+ * Deletes a registered system, addressed by its UUID or unique name.
+ *
+ * Roles V2 operation: `DELETE /systems/{systemIdentifier}` — "Delete a system by identifier."
+ *
+ * Curried in two stages: `deleteSystem(version, client, method)` binds the API version, the
+ * `IHttpClient` that reaches the Roles service, and the execution method — `'json'` for a
+ * promise, `'json$'` for an observable stream. The returned function takes
+ * {@link DeleteSystemArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link DeleteSystemResult}.
+ *
+ * The version argument is the single discriminator: `'v1'` — equivalently `'1.0'` or
+ * `ApiVersion.v1` — selects the version-1.0 argument schema, expects the empty success body,
+ * and sends `api-version=1.0` on the request.
+ *
+ * Destructive: it removes the registered system permanently, and the deletion cannot be undone
+ * through this API. Roles V2 answers `204 No Content` with no body, so the resolved value is
+ * `void`. The contract declares `403 Forbidden` for callers the Roles service does not
+ * authorise for this operation.
+ *
+ * @template TVersion - Roles API version identifier: `'v1'`, `'1.0'`, or `ApiVersion.v1`.
+ * @template TMethod - Execution method: `'json'` for a promise, `'json$'` for an observable.
+ * @param version - API version selecting the request path, the argument schema, and the
+ * response schema.
+ * @param client - HTTP client that executes the request against the Roles service.
+ * @param method - Execution method, defaulting to `'json'`.
+ * @returns A request function taking {@link DeleteSystemArg} and an optional
+ * `ClientRequestInit`, returning {@link DeleteSystemResult}.
+ * @throws {Error} When `version` names an API version this operation does not publish. The
+ * check runs while binding, before the HTTP client is used.
+ * @throws {z.ZodError} From the returned function, when the arguments fail this version's
+ * argument schema or the response body fails its response schema.
+ *
+ * @example
+ * ```ts
+ * import { deleteSystem } from '@equinor/fusion-services/roles';
+ *
+ * await deleteSystem('v1', httpClient)({ systemIdentifier: 'fusion-core' });
+ * ```
+ */
+declare const deleteSystem: <TVersion extends DeleteSystemVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: DeleteSystemArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, DeleteSystemResponse<ExtractApiVersion<TVersion>>>) => DeleteSystemResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type DeleteSystemArg, type DeleteSystemResponse, type DeleteSystemResult, type DeleteSystemVersion, deleteSystem, };