@equinor/fusion-services 0.2.0

package/dist/types/roles/endpoints/scope-type.patch.d.ts

@@ -0,0 +1,110 @@
+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 `updateScopeType` accepts for
+ * `PATCH /scope-types/{scopeTypeIdentifier}`.
+ *
+ * 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 UpdateScopeTypeArg} and {@link UpdateScopeTypeResponse}.
+ */
+type UpdateScopeTypeVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `updateScopeType`, implementing
+ * `PATCH /scope-types/{scopeTypeIdentifier}`.
+ *
+ * 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>>;
+            scopeTypeIdentifier: 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.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `updateScopeType` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiScopeTypeV1`, inferred from `ApiScopeTypeSchemaV1` — the very
+ * schema that validates the `200 OK` body at runtime.
+ */
+type UpdateScopeTypeResponse<TVersion extends UpdateScopeTypeVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `updateScopeType` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `scopeTypeIdentifier`, and the request body fields of
+ * `UpdateScopeRequestV1`.
+ *
+ * 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 UpdateScopeTypeArg<TVersion extends UpdateScopeTypeVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `updateScopeType` hands back once the request runs, for the selected API version and
+ * client method.
+ *
+ * `'json'` gives `Promise<UpdateScopeTypeResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<UpdateScopeTypeResponse<TVersion>>`, so promise and observable callers share
+ * one response type.
+ */
+type UpdateScopeTypeResult<TVersion extends UpdateScopeTypeVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<UpdateScopeTypeResponse<TVersion>>[TMethod];
+/**
+ * Updates the description of a scope type.
+ *
+ * Roles V2 operation: `PATCH /scope-types/{scopeTypeIdentifier}` — "Update a scope type by
+ * identifier."
+ *
+ * Curried in two stages: `updateScopeType(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 UpdateScopeTypeArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link UpdateScopeTypeResult}.
+ *
+ * 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
+ * `ApiScopeTypeSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiScopeTypeV1`. 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 UpdateScopeTypeArg} and an optional
+ * `ClientRequestInit`, returning {@link UpdateScopeTypeResult}.
+ * @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 { updateScopeType } from '@equinor/fusion-services/roles';
+ *
+ * const scopeType = await updateScopeType('v1', httpClient)({
+ *   scopeTypeIdentifier: 'project',
+ *   description: 'Project scope',
+ * });
+ * ```
+ */
+declare const updateScopeType: <TVersion extends UpdateScopeTypeVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: UpdateScopeTypeArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, UpdateScopeTypeResponse<ExtractApiVersion<TVersion>>>) => UpdateScopeTypeResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type UpdateScopeTypeArg, type UpdateScopeTypeResponse, type UpdateScopeTypeResult, type UpdateScopeTypeVersion, updateScopeType, };

package/dist/types/roles/endpoints/scope-types.get.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 `listScopeTypes` accepts for `GET /scope-types`.
+ *
+ * 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 ListScopeTypesArg} and {@link ListScopeTypesResponse}.
+ */
+type ListScopeTypesVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listScopeTypes`, implementing `GET /scope-types`.
+ *
+ * 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<{}, 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.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    };
+};
+/**
+ * Response body `listScopeTypes` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiScopeTypeV1[]`, inferred from `z.array(ApiScopeTypeSchemaV1)` —
+ * the very schema that validates the `200 OK` body at runtime.
+ */
+type ListScopeTypesResponse<TVersion extends ListScopeTypesVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listScopeTypes` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 of this operation takes no arguments, so the shape is an empty object.
+ *
+ * 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 ListScopeTypesArg<TVersion extends ListScopeTypesVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listScopeTypes` hands back once the request runs, for the selected API version and
+ * client method.
+ *
+ * `'json'` gives `Promise<ListScopeTypesResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<ListScopeTypesResponse<TVersion>>`, so promise and observable callers share
+ * one response type.
+ */
+type ListScopeTypesResult<TVersion extends ListScopeTypesVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListScopeTypesResponse<TVersion>>[TMethod];
+/**
+ * Lists every scope type the Roles service publishes.
+ *
+ * Roles V2 operation: `GET /scope-types` — "Get all scope types."
+ *
+ * Curried in two stages: `listScopeTypes(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 ListScopeTypesArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link ListScopeTypesResult}.
+ *
+ * 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(ApiScopeTypeSchemaV1)`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiScopeTypeV1[]`.
+ *
+ * @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 ListScopeTypesArg} and an optional
+ * `ClientRequestInit`, returning {@link ListScopeTypesResult}.
+ * @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 { listScopeTypes } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listScopeTypes('v1', httpClient)({});
+ * ```
+ */
+declare const listScopeTypes: <TVersion extends ListScopeTypesVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input?: ListScopeTypesArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListScopeTypesResponse<ExtractApiVersion<TVersion>>>) => ListScopeTypesResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListScopeTypesArg, type ListScopeTypesResponse, type ListScopeTypesResult, type ListScopeTypesVersion, listScopeTypes, };

package/dist/types/roles/endpoints/scope-types.post.d.ts

@@ -0,0 +1,106 @@
+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 `createScopeType` accepts for `POST /scope-types`.
+ *
+ * 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 CreateScopeTypeArg} and {@link CreateScopeTypeResponse}.
+ */
+type CreateScopeTypeVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `createScopeType`, implementing `POST /scope-types`.
+ *
+ * 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>;
+        }, 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.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `createScopeType` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiScopeTypeV1`, inferred from `ApiScopeTypeSchemaV1` — the very
+ * schema that validates the `201 Created` body at runtime.
+ */
+type CreateScopeTypeResponse<TVersion extends CreateScopeTypeVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `createScopeType` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the request body fields of `CreateScopeTypeRequestV1`.
+ *
+ * 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 CreateScopeTypeArg<TVersion extends CreateScopeTypeVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `createScopeType` hands back once the request runs, for the selected API version and
+ * client method.
+ *
+ * `'json'` gives `Promise<CreateScopeTypeResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<CreateScopeTypeResponse<TVersion>>`, so promise and observable callers share
+ * one response type.
+ */
+type CreateScopeTypeResult<TVersion extends CreateScopeTypeVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<CreateScopeTypeResponse<TVersion>>[TMethod];
+/**
+ * Creates a scope type, the vocabulary that role assignment scopes are expressed in.
+ *
+ * Roles V2 operation: `POST /scope-types` — "Create a new scope type."
+ *
+ * Curried in two stages: `createScopeType(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 CreateScopeTypeArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link CreateScopeTypeResult}.
+ *
+ * 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
+ * `ApiScopeTypeSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `201 Created`; the body is typed `ApiScopeTypeV1`. A colliding name answers
+ * `409 Conflict`. 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 CreateScopeTypeArg} and an optional
+ * `ClientRequestInit`, returning {@link CreateScopeTypeResult}.
+ * @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 { createScopeType } from '@equinor/fusion-services/roles';
+ *
+ * const scopeType = await createScopeType('v1', httpClient)({
+ *   name: 'project',
+ *   description: 'Project scope',
+ * });
+ * ```
+ */
+declare const createScopeType: <TVersion extends CreateScopeTypeVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input?: CreateScopeTypeArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, CreateScopeTypeResponse<ExtractApiVersion<TVersion>>>) => CreateScopeTypeResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type CreateScopeTypeArg, type CreateScopeTypeResponse, type CreateScopeTypeResult, type CreateScopeTypeVersion, createScopeType, };

package/dist/types/roles/endpoints/system-access-role-assignment.delete.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 `deleteSystemAccessRoleAssignment` accepts for
+ * `DELETE /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}/assignments/{accessRoleAssignmentId}`.
+ *
+ * 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 DeleteSystemAccessRoleAssignmentArg} and
+ * {@link DeleteSystemAccessRoleAssignmentResponse}.
+ */
+type DeleteSystemAccessRoleAssignmentVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `deleteSystemAccessRoleAssignment`, implementing
+ * `DELETE /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}/assignments/{accessRoleAssignmentId}`.
+ *
+ * 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;
+            accessRoleAssignmentId: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0. The operation answers `204 No Content`. */
+        readonly response: z.ZodVoid;
+    };
+};
+/**
+ * Response body `deleteSystemAccessRoleAssignment` resolves for the selected API version.
+ *
+ * Version 1.0 answers `204 No Content` without a body, so the type resolves to `void`.
+ */
+type DeleteSystemAccessRoleAssignmentResponse<TVersion extends DeleteSystemAccessRoleAssignmentVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `deleteSystemAccessRoleAssignment` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifiers `systemIdentifier`, `accessRoleIdentifier`,
+ * `accessRoleAssignmentId`.
+ *
+ * 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 DeleteSystemAccessRoleAssignmentArg<TVersion extends DeleteSystemAccessRoleAssignmentVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `deleteSystemAccessRoleAssignment` hands back once the request runs, for the selected
+ * API version and client method.
+ *
+ * `'json'` gives `Promise<DeleteSystemAccessRoleAssignmentResponse<TVersion>>` and `'json$'`
+ * gives `StreamResponse<DeleteSystemAccessRoleAssignmentResponse<TVersion>>`, so promise and
+ * observable callers share one response type.
+ */
+type DeleteSystemAccessRoleAssignmentResult<TVersion extends DeleteSystemAccessRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<DeleteSystemAccessRoleAssignmentResponse<TVersion>>[TMethod];
+/**
+ * Deletes one assignment of a system access role, addressed by its assignment ID.
+ *
+ * Roles V2 operation:
+ * `DELETE /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}/assignments/{accessRoleAssignmentId}`
+ * — "Delete an access role assignment by ID."
+ *
+ * Curried in two stages: `deleteSystemAccessRoleAssignment(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 DeleteSystemAccessRoleAssignmentArg} plus an optional `ClientRequestInit`, and gives
+ * back {@link DeleteSystemAccessRoleAssignmentResult}.
+ *
+ * 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 assignment 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 DeleteSystemAccessRoleAssignmentArg} and an
+ * optional `ClientRequestInit`, returning {@link DeleteSystemAccessRoleAssignmentResult}.
+ * @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 { deleteSystemAccessRoleAssignment } from '@equinor/fusion-services/roles';
+ *
+ * await deleteSystemAccessRoleAssignment('v1', httpClient)({
+ *   systemIdentifier: 'fusion-core',
+ *   accessRoleIdentifier: 'writer',
+ *   accessRoleAssignmentId: '4d2c9a71-5e6f-4b80-9c12-3a4b5c6d7e8f',
+ * });
+ * ```
+ */
+declare const deleteSystemAccessRoleAssignment: <TVersion extends DeleteSystemAccessRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: DeleteSystemAccessRoleAssignmentArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, DeleteSystemAccessRoleAssignmentResponse<ExtractApiVersion<TVersion>>>) => DeleteSystemAccessRoleAssignmentResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type DeleteSystemAccessRoleAssignmentArg, type DeleteSystemAccessRoleAssignmentResponse, type DeleteSystemAccessRoleAssignmentResult, type DeleteSystemAccessRoleAssignmentVersion, deleteSystemAccessRoleAssignment, };

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

@@ -0,0 +1,182 @@
+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 `getSystemAccessRoleAssignment` accepts for
+ * `GET /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}/assignments/{accessRoleAssignmentId}`.
+ *
+ * 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 GetSystemAccessRoleAssignmentArg} and {@link GetSystemAccessRoleAssignmentResponse}.
+ */
+type GetSystemAccessRoleAssignmentVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `getSystemAccessRoleAssignment`, implementing
+ * `GET /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}/assignments/{accessRoleAssignmentId}`.
+ *
+ * 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;
+            accessRoleAssignmentId: z.ZodString;
+            expand: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            assignedTo: z.ZodOptional<z.ZodObject<{
+                azureUniqueId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                mail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                displayName: z.ZodOptional<z.ZodString>;
+                upn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                accountType: z.ZodOptional<z.ZodString>;
+                accountClassification: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+            reason: z.ZodOptional<z.ZodString>;
+            source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            externalIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            type: z.ZodOptional<z.ZodString>;
+            scope: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                isGlobal: z.ZodBoolean;
+                value: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>>;
+            validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            validTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            isActive: z.ZodOptional<z.ZodBoolean>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            accessRole: z.ZodOptional<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>>;
+            roleAssignment: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                role: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    displayName: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                    system: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                        id: z.ZodOptional<z.ZodString>;
+                        name: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            claimableRoleAssignment: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                claimableRole: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    displayName: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                    accessRoleMappings: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                        accessRole: z.ZodOptional<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>>;
+                        reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>>>>;
+                    system: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                        id: z.ZodOptional<z.ZodString>;
+                        name: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `getSystemAccessRoleAssignment` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiAccessRoleAssignmentV1`, inferred from
+ * `ApiAccessRoleAssignmentSchemaV1` — the very schema that validates the `200 OK` body at
+ * runtime.
+ */
+type GetSystemAccessRoleAssignmentResponse<TVersion extends GetSystemAccessRoleAssignmentVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `getSystemAccessRoleAssignment` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifiers `systemIdentifier`, `accessRoleIdentifier`,
+ * `accessRoleAssignmentId`, and the optional query options `expand`.
+ *
+ * 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 GetSystemAccessRoleAssignmentArg<TVersion extends GetSystemAccessRoleAssignmentVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `getSystemAccessRoleAssignment` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<GetSystemAccessRoleAssignmentResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<GetSystemAccessRoleAssignmentResponse<TVersion>>`, so promise and observable
+ * callers share one response type.
+ */
+type GetSystemAccessRoleAssignmentResult<TVersion extends GetSystemAccessRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<GetSystemAccessRoleAssignmentResponse<TVersion>>[TMethod];
+/**
+ * Fetches one assignment of a system access role, addressed by its assignment ID.
+ *
+ * Roles V2 operation:
+ * `GET /systems/{systemIdentifier}/access-roles/{accessRoleIdentifier}/assignments/{accessRoleAssignmentId}`
+ * — "Get an access role assignment by ID."
+ *
+ * Curried in two stages: `getSystemAccessRoleAssignment(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 GetSystemAccessRoleAssignmentArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link GetSystemAccessRoleAssignmentResult}.
+ *
+ * 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
+ * `ApiAccessRoleAssignmentSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Query options: `expand` is sent as `$expand` to inline related resources.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiAccessRoleAssignmentV1`.
+ *
+ * @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 GetSystemAccessRoleAssignmentArg} and an optional
+ * `ClientRequestInit`, returning {@link GetSystemAccessRoleAssignmentResult}.
+ * @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 { getSystemAccessRoleAssignment } from '@equinor/fusion-services/roles';
+ *
+ * const assignment = await getSystemAccessRoleAssignment('v1', httpClient)({
+ *   systemIdentifier: 'fusion-core',
+ *   accessRoleIdentifier: 'writer',
+ *   accessRoleAssignmentId: '4d2c9a71-5e6f-4b80-9c12-3a4b5c6d7e8f',
+ * });
+ * ```
+ */
+declare const getSystemAccessRoleAssignment: <TVersion extends GetSystemAccessRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: GetSystemAccessRoleAssignmentArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, GetSystemAccessRoleAssignmentResponse<ExtractApiVersion<TVersion>>>) => GetSystemAccessRoleAssignmentResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type GetSystemAccessRoleAssignmentArg, type GetSystemAccessRoleAssignmentResponse, type GetSystemAccessRoleAssignmentResult, type GetSystemAccessRoleAssignmentVersion, getSystemAccessRoleAssignment, };