@equinor/fusion-services 0.2.0

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

@@ -0,0 +1,150 @@
+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 `addRoleAccessRoles` accepts for
+ * `POST /roles/{roleIdentifier}/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 AddRoleAccessRolesArg} and {@link AddRoleAccessRolesResponse}.
+ */
+type AddRoleAccessRolesVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `addRoleAccessRoles`, implementing
+ * `POST /roles/{roleIdentifier}/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<{
+            accessRoleMappings: z.ZodArray<z.ZodObject<{
+                accessRoleIdentifier: z.ZodOptional<z.ZodString>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            roleIdentifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodIntersection<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.ZodObject<{
+            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.ZodString>;
+            }, z.core.$strip>>>>;
+            createdBy: 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>>;
+            createdDate: z.ZodOptional<z.ZodString>;
+            updatedBy: z.ZodOptional<z.ZodNullable<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>>>;
+            updatedDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    };
+};
+/**
+ * Response body `addRoleAccessRoles` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiRoleV1`, inferred from `ApiRoleSchemaV1` — the very schema that
+ * validates the `201 Created` body at runtime.
+ */
+type AddRoleAccessRolesResponse<TVersion extends AddRoleAccessRolesVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `addRoleAccessRoles` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `roleIdentifier`, and the request body fields of
+ * `AddRoleAccessRoleRequestV1`.
+ *
+ * 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 AddRoleAccessRolesArg<TVersion extends AddRoleAccessRolesVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `addRoleAccessRoles` hands back once the request runs, for the selected API version and
+ * client method.
+ *
+ * `'json'` gives `Promise<AddRoleAccessRolesResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<AddRoleAccessRolesResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type AddRoleAccessRolesResult<TVersion extends AddRoleAccessRolesVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<AddRoleAccessRolesResponse<TVersion>>[TMethod];
+/**
+ * Adds one or more access role mappings to a role, so every holder of the role gains the mapped
+ * access roles.
+ *
+ * Roles V2 operation: `POST /roles/{roleIdentifier}/access-roles` — "Add one or more access
+ * role mappings to a role."
+ *
+ * Curried in two stages: `addRoleAccessRoles(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 AddRoleAccessRolesArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link AddRoleAccessRolesResult}.
+ *
+ * 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
+ * `ApiRoleSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `201 Created`; the body is typed `ApiRoleV1`. 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 AddRoleAccessRolesArg} and an optional
+ * `ClientRequestInit`, returning {@link AddRoleAccessRolesResult}.
+ * @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 { addRoleAccessRoles } from '@equinor/fusion-services/roles';
+ *
+ * const role = await addRoleAccessRoles('v1', httpClient)({
+ *   roleIdentifier: 'reader',
+ *   accessRoleMappings: [{ accessRoleIdentifier: 'writer' }],
+ * });
+ * ```
+ */
+declare const addRoleAccessRoles: <TVersion extends AddRoleAccessRolesVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: AddRoleAccessRolesArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, AddRoleAccessRolesResponse<ExtractApiVersion<TVersion>>>) => AddRoleAccessRolesResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type AddRoleAccessRolesArg, type AddRoleAccessRolesResponse, type AddRoleAccessRolesResult, type AddRoleAccessRolesVersion, addRoleAccessRoles, };

package/dist/types/roles/endpoints/role-assignment.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 `deleteRoleAssignment` accepts for
+ * `DELETE /roles/{roleIdentifier}/assignments/{roleAssignmentId}`.
+ *
+ * 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 DeleteRoleAssignmentArg} and {@link DeleteRoleAssignmentResponse}.
+ */
+type DeleteRoleAssignmentVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `deleteRoleAssignment`, implementing
+ * `DELETE /roles/{roleIdentifier}/assignments/{roleAssignmentId}`.
+ *
+ * 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<{
+            roleIdentifier: z.ZodString;
+            roleAssignmentId: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0. The operation answers `204 No Content`. */
+        readonly response: z.ZodVoid;
+    };
+};
+/**
+ * Response body `deleteRoleAssignment` resolves for the selected API version.
+ *
+ * Version 1.0 answers `204 No Content` without a body, so the type resolves to `void`.
+ */
+type DeleteRoleAssignmentResponse<TVersion extends DeleteRoleAssignmentVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `deleteRoleAssignment` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifiers `roleIdentifier`, `roleAssignmentId`.
+ *
+ * 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 DeleteRoleAssignmentArg<TVersion extends DeleteRoleAssignmentVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `deleteRoleAssignment` hands back once the request runs, for the selected API version
+ * and client method.
+ *
+ * `'json'` gives `Promise<DeleteRoleAssignmentResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<DeleteRoleAssignmentResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type DeleteRoleAssignmentResult<TVersion extends DeleteRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<DeleteRoleAssignmentResponse<TVersion>>[TMethod];
+/**
+ * Deletes one assignment of a role, addressed by its assignment ID.
+ *
+ * Roles V2 operation: `DELETE /roles/{roleIdentifier}/assignments/{roleAssignmentId}` — "Delete
+ * a role assignment by its ID"
+ *
+ * Curried in two stages: `deleteRoleAssignment(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 DeleteRoleAssignmentArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link DeleteRoleAssignmentResult}.
+ *
+ * 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 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 DeleteRoleAssignmentArg} and an optional
+ * `ClientRequestInit`, returning {@link DeleteRoleAssignmentResult}.
+ * @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 { deleteRoleAssignment } from '@equinor/fusion-services/roles';
+ *
+ * await deleteRoleAssignment('v1', httpClient)({
+ *   roleIdentifier: 'reader',
+ *   roleAssignmentId: '0f5a8d1c-2b3e-4a6f-9c10-7d8e9f0a1b2c',
+ * });
+ * ```
+ */
+declare const deleteRoleAssignment: <TVersion extends DeleteRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: DeleteRoleAssignmentArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, DeleteRoleAssignmentResponse<ExtractApiVersion<TVersion>>>) => DeleteRoleAssignmentResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type DeleteRoleAssignmentArg, type DeleteRoleAssignmentResponse, type DeleteRoleAssignmentResult, type DeleteRoleAssignmentVersion, deleteRoleAssignment, };

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

@@ -0,0 +1,138 @@
+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 `getRoleAssignment` accepts for
+ * `GET /roles/{roleIdentifier}/assignments/{roleAssignmentId}`.
+ *
+ * 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 GetRoleAssignmentArg} and {@link GetRoleAssignmentResponse}.
+ */
+type GetRoleAssignmentVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `getRoleAssignment`, implementing
+ * `GET /roles/{roleIdentifier}/assignments/{roleAssignmentId}`.
+ *
+ * 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<{
+            roleIdentifier: z.ZodString;
+            roleAssignmentId: 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>>;
+            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>>;
+            source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            externalIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            reason: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+            validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            validTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            scope: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                isGlobal: z.ZodBoolean;
+                value: z.ZodNullable<z.ZodString>;
+                scopeTypeIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `getRoleAssignment` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiRoleAssignmentV1`, inferred from `ApiRoleAssignmentSchemaV1` —
+ * the very schema that validates the `200 OK` body at runtime.
+ */
+type GetRoleAssignmentResponse<TVersion extends GetRoleAssignmentVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `getRoleAssignment` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifiers `roleIdentifier`, `roleAssignmentId`.
+ *
+ * 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 GetRoleAssignmentArg<TVersion extends GetRoleAssignmentVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `getRoleAssignment` hands back once the request runs, for the selected API version and
+ * client method.
+ *
+ * `'json'` gives `Promise<GetRoleAssignmentResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<GetRoleAssignmentResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type GetRoleAssignmentResult<TVersion extends GetRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<GetRoleAssignmentResponse<TVersion>>[TMethod];
+/**
+ * Fetches one assignment of a role, addressed by its assignment ID: the account holding it,
+ * the scope it applies to, and how long it lasts.
+ *
+ * Roles V2 operation: `GET /roles/{roleIdentifier}/assignments/{roleAssignmentId}` — "Get role
+ * assignment by role assignment ID."
+ *
+ * Curried in two stages: `getRoleAssignment(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 GetRoleAssignmentArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link GetRoleAssignmentResult}.
+ *
+ * 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
+ * `ApiRoleAssignmentSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiRoleAssignmentV1`.
+ *
+ * Related: `listRoleAssignments` lists every account holding the role, and
+ * `updateRoleAssignment` changes how long this one lasts.
+ *
+ * @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 GetRoleAssignmentArg} and an optional
+ * `ClientRequestInit`, returning {@link GetRoleAssignmentResult}.
+ * @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 { getRoleAssignment } from '@equinor/fusion-services/roles';
+ *
+ * const assignment = await getRoleAssignment('v1', httpClient)({
+ *   roleIdentifier: 'reader',
+ *   roleAssignmentId: '0f5a8d1c-2b3e-4a6f-9c10-7d8e9f0a1b2c',
+ * });
+ * ```
+ */
+declare const getRoleAssignment: <TVersion extends GetRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: GetRoleAssignmentArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, GetRoleAssignmentResponse<ExtractApiVersion<TVersion>>>) => GetRoleAssignmentResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type GetRoleAssignmentArg, type GetRoleAssignmentResponse, type GetRoleAssignmentResult, type GetRoleAssignmentVersion, getRoleAssignment, };

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

@@ -0,0 +1,140 @@
+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 `updateRoleAssignment` accepts for
+ * `PATCH /roles/{roleIdentifier}/assignments/{roleAssignmentId}`.
+ *
+ * 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 UpdateRoleAssignmentArg} and {@link UpdateRoleAssignmentResponse}.
+ */
+type UpdateRoleAssignmentVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `updateRoleAssignment`, implementing
+ * `PATCH /roles/{roleIdentifier}/assignments/{roleAssignmentId}`.
+ *
+ * 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<{
+            validTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            roleIdentifier: z.ZodString;
+            roleAssignmentId: 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>>;
+            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>>;
+            source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            externalIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            reason: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+            validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            validTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            scope: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                isGlobal: z.ZodBoolean;
+                value: z.ZodNullable<z.ZodString>;
+                scopeTypeIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `updateRoleAssignment` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiRoleAssignmentV1`, inferred from `ApiRoleAssignmentSchemaV1` —
+ * the very schema that validates the `200 OK` body at runtime.
+ */
+type UpdateRoleAssignmentResponse<TVersion extends UpdateRoleAssignmentVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `updateRoleAssignment` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifiers `roleIdentifier`, `roleAssignmentId`, and the
+ * request body fields of `UpdateRoleAssignmentRequestV1`.
+ *
+ * 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 UpdateRoleAssignmentArg<TVersion extends UpdateRoleAssignmentVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `updateRoleAssignment` hands back once the request runs, for the selected API version
+ * and client method.
+ *
+ * `'json'` gives `Promise<UpdateRoleAssignmentResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<UpdateRoleAssignmentResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type UpdateRoleAssignmentResult<TVersion extends UpdateRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<UpdateRoleAssignmentResponse<TVersion>>[TMethod];
+/**
+ * Extends or shortens a role assignment by updating its `validTo` date.
+ *
+ * Roles V2 operation: `PATCH /roles/{roleIdentifier}/assignments/{roleAssignmentId}` — "Update
+ * a role assignment's valid to date."
+ *
+ * Curried in two stages: `updateRoleAssignment(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 UpdateRoleAssignmentArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link UpdateRoleAssignmentResult}.
+ *
+ * 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
+ * `ApiRoleAssignmentSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiRoleAssignmentV1`. 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 UpdateRoleAssignmentArg} and an optional
+ * `ClientRequestInit`, returning {@link UpdateRoleAssignmentResult}.
+ * @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 { updateRoleAssignment } from '@equinor/fusion-services/roles';
+ *
+ * const assignment = await updateRoleAssignment('v1', httpClient)({
+ *   roleIdentifier: 'reader',
+ *   roleAssignmentId: '0f5a8d1c-2b3e-4a6f-9c10-7d8e9f0a1b2c',
+ *   validTo: '2026-06-30T23:59:59Z',
+ * });
+ * ```
+ */
+declare const updateRoleAssignment: <TVersion extends UpdateRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: UpdateRoleAssignmentArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, UpdateRoleAssignmentResponse<ExtractApiVersion<TVersion>>>) => UpdateRoleAssignmentResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type UpdateRoleAssignmentArg, type UpdateRoleAssignmentResponse, type UpdateRoleAssignmentResult, type UpdateRoleAssignmentVersion, updateRoleAssignment, };

package/dist/types/roles/endpoints/role-assignments-by-external-identifier.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 `deleteRoleAssignmentsByExternalIdentifier` accepts for
+ * `DELETE /role-assignments/{externalIdentifier}`.
+ *
+ * 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 DeleteRoleAssignmentsByExternalIdentifierArg} and
+ * {@link DeleteRoleAssignmentsByExternalIdentifierResponse}.
+ */
+type DeleteRoleAssignmentsByExternalIdentifierVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `deleteRoleAssignmentsByExternalIdentifier`, implementing
+ * `DELETE /role-assignments/{externalIdentifier}`.
+ *
+ * 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<{
+            externalIdentifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0. The operation answers `204 No Content`. */
+        readonly response: z.ZodVoid;
+    };
+};
+/**
+ * Response body `deleteRoleAssignmentsByExternalIdentifier` resolves for the selected API
+ * version.
+ *
+ * Version 1.0 answers `204 No Content` without a body, so the type resolves to `void`.
+ */
+type DeleteRoleAssignmentsByExternalIdentifierResponse<TVersion extends DeleteRoleAssignmentsByExternalIdentifierVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `deleteRoleAssignmentsByExternalIdentifier` accepts, resolved from the selected API
+ * version.
+ *
+ * Version 1.0 accepts the path identifier `externalIdentifier`.
+ *
+ * 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 DeleteRoleAssignmentsByExternalIdentifierArg<TVersion extends DeleteRoleAssignmentsByExternalIdentifierVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `deleteRoleAssignmentsByExternalIdentifier` hands back once the request runs, for the
+ * selected API version and client method.
+ *
+ * `'json'` gives `Promise<DeleteRoleAssignmentsByExternalIdentifierResponse<TVersion>>` and
+ * `'json$'` gives
+ * `StreamResponse<DeleteRoleAssignmentsByExternalIdentifierResponse<TVersion>>`, so promise and
+ * observable callers share one response type.
+ */
+type DeleteRoleAssignmentsByExternalIdentifierResult<TVersion extends DeleteRoleAssignmentsByExternalIdentifierVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<DeleteRoleAssignmentsByExternalIdentifierResponse<TVersion>>[TMethod];
+/**
+ * Deletes every role assignment carrying one external identifier, across all roles.
+ *
+ * Roles V2 operation: `DELETE /role-assignments/{externalIdentifier}` — "Delete all role
+ * assignments matching the provided external identifier across all roles. This operation is
+ * idempotent — if no matching assignments exist, a 204 is still returned."
+ *
+ * Curried in two stages: `deleteRoleAssignmentsByExternalIdentifier(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 DeleteRoleAssignmentsByExternalIdentifierArg} plus an optional
+ * `ClientRequestInit`, and gives back {@link DeleteRoleAssignmentsByExternalIdentifierResult}.
+ *
+ * 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 every matching role assignment permanently, and the deletion cannot
+ * be undone through this API. The operation is idempotent, so a request matching nothing still
+ * answers `204 No Content`. 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 DeleteRoleAssignmentsByExternalIdentifierArg} and
+ * an optional `ClientRequestInit`, returning
+ * {@link DeleteRoleAssignmentsByExternalIdentifierResult}.
+ * @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 { deleteRoleAssignmentsByExternalIdentifier } from '@equinor/fusion-services/roles';
+ *
+ * await deleteRoleAssignmentsByExternalIdentifier('v1', httpClient)({
+ *   externalIdentifier: 'sap-2f10c9',
+ * });
+ * ```
+ */
+declare const deleteRoleAssignmentsByExternalIdentifier: <TVersion extends DeleteRoleAssignmentsByExternalIdentifierVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: DeleteRoleAssignmentsByExternalIdentifierArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, DeleteRoleAssignmentsByExternalIdentifierResponse<ExtractApiVersion<TVersion>>>) => DeleteRoleAssignmentsByExternalIdentifierResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type DeleteRoleAssignmentsByExternalIdentifierArg, type DeleteRoleAssignmentsByExternalIdentifierResponse, type DeleteRoleAssignmentsByExternalIdentifierResult, type DeleteRoleAssignmentsByExternalIdentifierVersion, deleteRoleAssignmentsByExternalIdentifier, };