@equinor/fusion-services 0.2.0

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

@@ -0,0 +1,152 @@
+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 `getClaimableRoleAssignment` accepts for
+ * `GET /claimable-roles/{claimableRoleIdentifier}/assignments/{claimableRoleAssignmentId}`.
+ *
+ * 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 GetClaimableRoleAssignmentArg} and {@link GetClaimableRoleAssignmentResponse}.
+ */
+type GetClaimableRoleAssignmentVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `getClaimableRoleAssignment`, implementing
+ * `GET /claimable-roles/{claimableRoleIdentifier}/assignments/{claimableRoleAssignmentId}`.
+ *
+ * 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<{
+            claimableRoleIdentifier: z.ZodString;
+            claimableRoleAssignmentId: 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>>;
+            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>>;
+            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>>;
+            isActive: z.ZodOptional<z.ZodBoolean>;
+            activeTo: 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 `getClaimableRoleAssignment` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiClaimableRoleAssignmentV1`, inferred from
+ * `ApiClaimableRoleAssignmentSchemaV1` — the very schema that validates the `200 OK` body at
+ * runtime.
+ */
+type GetClaimableRoleAssignmentResponse<TVersion extends GetClaimableRoleAssignmentVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `getClaimableRoleAssignment` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifiers `claimableRoleIdentifier`,
+ * `claimableRoleAssignmentId`.
+ *
+ * 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 GetClaimableRoleAssignmentArg<TVersion extends GetClaimableRoleAssignmentVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `getClaimableRoleAssignment` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<GetClaimableRoleAssignmentResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<GetClaimableRoleAssignmentResponse<TVersion>>`, so promise and observable
+ * callers share one response type.
+ */
+type GetClaimableRoleAssignmentResult<TVersion extends GetClaimableRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<GetClaimableRoleAssignmentResponse<TVersion>>[TMethod];
+/**
+ * Fetches one assignment of a claimable role, addressed by its assignment ID.
+ *
+ * Roles V2 operation:
+ * `GET /claimable-roles/{claimableRoleIdentifier}/assignments/{claimableRoleAssignmentId}` —
+ * "Get a claimable role assignment by ID."
+ *
+ * Curried in two stages: `getClaimableRoleAssignment(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 GetClaimableRoleAssignmentArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link GetClaimableRoleAssignmentResult}.
+ *
+ * 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
+ * `ApiClaimableRoleAssignmentSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiClaimableRoleAssignmentV1`.
+ *
+ * @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 GetClaimableRoleAssignmentArg} and an optional
+ * `ClientRequestInit`, returning {@link GetClaimableRoleAssignmentResult}.
+ * @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 { getClaimableRoleAssignment } from '@equinor/fusion-services/roles';
+ *
+ * const assignment = await getClaimableRoleAssignment('v1', httpClient)({
+ *   claimableRoleIdentifier: 'on-call-approver',
+ *   claimableRoleAssignmentId: '6b1d4f2a-8c3e-4d59-9f70-1a2b3c4d5e6f',
+ * });
+ * ```
+ */
+declare const getClaimableRoleAssignment: <TVersion extends GetClaimableRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: GetClaimableRoleAssignmentArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, GetClaimableRoleAssignmentResponse<ExtractApiVersion<TVersion>>>) => GetClaimableRoleAssignmentResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type GetClaimableRoleAssignmentArg, type GetClaimableRoleAssignmentResponse, type GetClaimableRoleAssignmentResult, type GetClaimableRoleAssignmentVersion, getClaimableRoleAssignment, };

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

@@ -0,0 +1,158 @@
+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 `updateClaimableRoleAssignment` accepts for
+ * `PATCH /claimable-roles/{claimableRoleIdentifier}/assignments/{claimableRoleAssignmentId}`.
+ *
+ * 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 UpdateClaimableRoleAssignmentArg} and {@link UpdateClaimableRoleAssignmentResponse}.
+ */
+type UpdateClaimableRoleAssignmentVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `updateClaimableRoleAssignment`, implementing
+ * `PATCH /claimable-roles/{claimableRoleIdentifier}/assignments/{claimableRoleAssignmentId}`.
+ *
+ * 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>>;
+            claimableRoleIdentifier: z.ZodString;
+            claimableRoleAssignmentId: 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>>;
+            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>>;
+            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>>;
+            isActive: z.ZodOptional<z.ZodBoolean>;
+            activeTo: 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 `updateClaimableRoleAssignment` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiClaimableRoleAssignmentV1`, inferred from
+ * `ApiClaimableRoleAssignmentSchemaV1` — the very schema that validates the `200 OK` body at
+ * runtime.
+ */
+type UpdateClaimableRoleAssignmentResponse<TVersion extends UpdateClaimableRoleAssignmentVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `updateClaimableRoleAssignment` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifiers `claimableRoleIdentifier`,
+ * `claimableRoleAssignmentId`, and the request body fields of
+ * `UpdateClaimableRoleAssignmentRequestV1`.
+ *
+ * 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 UpdateClaimableRoleAssignmentArg<TVersion extends UpdateClaimableRoleAssignmentVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `updateClaimableRoleAssignment` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<UpdateClaimableRoleAssignmentResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<UpdateClaimableRoleAssignmentResponse<TVersion>>`, so promise and observable
+ * callers share one response type.
+ */
+type UpdateClaimableRoleAssignmentResult<TVersion extends UpdateClaimableRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<UpdateClaimableRoleAssignmentResponse<TVersion>>[TMethod];
+/**
+ * Extends or shortens a claimable role assignment by updating its `validTo` date.
+ *
+ * Roles V2 operation:
+ * `PATCH /claimable-roles/{claimableRoleIdentifier}/assignments/{claimableRoleAssignmentId}` —
+ * "Update a claimable role assignment's valid to date."
+ *
+ * Curried in two stages: `updateClaimableRoleAssignment(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 UpdateClaimableRoleAssignmentArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link UpdateClaimableRoleAssignmentResult}.
+ *
+ * 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
+ * `ApiClaimableRoleAssignmentSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiClaimableRoleAssignmentV1`. 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 UpdateClaimableRoleAssignmentArg} and an optional
+ * `ClientRequestInit`, returning {@link UpdateClaimableRoleAssignmentResult}.
+ * @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 { updateClaimableRoleAssignment } from '@equinor/fusion-services/roles';
+ *
+ * const assignment = await updateClaimableRoleAssignment('v1', httpClient)({
+ *   claimableRoleIdentifier: 'on-call-approver',
+ *   claimableRoleAssignmentId: '6b1d4f2a-8c3e-4d59-9f70-1a2b3c4d5e6f',
+ *   validTo: '2026-06-30T23:59:59Z',
+ * });
+ * ```
+ */
+declare const updateClaimableRoleAssignment: <TVersion extends UpdateClaimableRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: UpdateClaimableRoleAssignmentArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, UpdateClaimableRoleAssignmentResponse<ExtractApiVersion<TVersion>>>) => UpdateClaimableRoleAssignmentResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type UpdateClaimableRoleAssignmentArg, type UpdateClaimableRoleAssignmentResponse, type UpdateClaimableRoleAssignmentResult, type UpdateClaimableRoleAssignmentVersion, updateClaimableRoleAssignment, };

package/dist/types/roles/endpoints/claimable-role-assignments-by-external-identifier.delete.d.ts

@@ -0,0 +1,113 @@
+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 `deleteClaimableRoleAssignmentsByExternalIdentifier` accepts for
+ * `DELETE /claimable-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 DeleteClaimableRoleAssignmentsByExternalIdentifierArg} and
+ * {@link DeleteClaimableRoleAssignmentsByExternalIdentifierResponse}.
+ */
+type DeleteClaimableRoleAssignmentsByExternalIdentifierVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `deleteClaimableRoleAssignmentsByExternalIdentifier`, implementing
+ * `DELETE /claimable-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 `deleteClaimableRoleAssignmentsByExternalIdentifier` resolves for the selected
+ * API version.
+ *
+ * Version 1.0 answers `204 No Content` without a body, so the type resolves to `void`.
+ */
+type DeleteClaimableRoleAssignmentsByExternalIdentifierResponse<TVersion extends DeleteClaimableRoleAssignmentsByExternalIdentifierVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `deleteClaimableRoleAssignmentsByExternalIdentifier` 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 DeleteClaimableRoleAssignmentsByExternalIdentifierArg<TVersion extends DeleteClaimableRoleAssignmentsByExternalIdentifierVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `deleteClaimableRoleAssignmentsByExternalIdentifier` hands back once the request runs,
+ * for the selected API version and client method.
+ *
+ * `'json'` gives
+ * `Promise<DeleteClaimableRoleAssignmentsByExternalIdentifierResponse<TVersion>>` and `'json$'`
+ * gives `StreamResponse<DeleteClaimableRoleAssignmentsByExternalIdentifierResponse<TVersion>>`,
+ * so promise and observable callers share one response type.
+ */
+type DeleteClaimableRoleAssignmentsByExternalIdentifierResult<TVersion extends DeleteClaimableRoleAssignmentsByExternalIdentifierVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<DeleteClaimableRoleAssignmentsByExternalIdentifierResponse<TVersion>>[TMethod];
+/**
+ * Deletes every claimable role assignment carrying one external identifier, across all
+ * claimable roles.
+ *
+ * Roles V2 operation: `DELETE /claimable-role-assignments/{externalIdentifier}` — "Delete all
+ * claimable role assignments matching the provided external identifier across all claimable
+ * roles. This operation is idempotent — if no matching assignments exist, a 204 is still
+ * returned."
+ *
+ * Curried in two stages: `deleteClaimableRoleAssignmentsByExternalIdentifier(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 DeleteClaimableRoleAssignmentsByExternalIdentifierArg} plus an optional
+ * `ClientRequestInit`, and gives back
+ * {@link DeleteClaimableRoleAssignmentsByExternalIdentifierResult}.
+ *
+ * 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 claimable 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 DeleteClaimableRoleAssignmentsByExternalIdentifierArg} and an optional
+ * `ClientRequestInit`, returning
+ * {@link DeleteClaimableRoleAssignmentsByExternalIdentifierResult}.
+ * @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 { deleteClaimableRoleAssignmentsByExternalIdentifier } from '@equinor/fusion-services/roles';
+ *
+ * await deleteClaimableRoleAssignmentsByExternalIdentifier('v1', httpClient)({
+ *   externalIdentifier: 'sap-2f10c9',
+ * });
+ * ```
+ */
+declare const deleteClaimableRoleAssignmentsByExternalIdentifier: <TVersion extends DeleteClaimableRoleAssignmentsByExternalIdentifierVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: DeleteClaimableRoleAssignmentsByExternalIdentifierArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, DeleteClaimableRoleAssignmentsByExternalIdentifierResponse<ExtractApiVersion<TVersion>>>) => DeleteClaimableRoleAssignmentsByExternalIdentifierResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type DeleteClaimableRoleAssignmentsByExternalIdentifierArg, type DeleteClaimableRoleAssignmentsByExternalIdentifierResponse, type DeleteClaimableRoleAssignmentsByExternalIdentifierResult, type DeleteClaimableRoleAssignmentsByExternalIdentifierVersion, deleteClaimableRoleAssignmentsByExternalIdentifier, };

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

@@ -0,0 +1,211 @@
+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 `listClaimableRoleAssignments` accepts for
+ * `GET /claimable-roles/{claimableRoleIdentifier}/assignments`.
+ *
+ * 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 ListClaimableRoleAssignmentsArg} and {@link ListClaimableRoleAssignmentsResponse}.
+ */
+type ListClaimableRoleAssignmentsVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listClaimableRoleAssignments`, implementing
+ * `GET /claimable-roles/{claimableRoleIdentifier}/assignments`.
+ *
+ * 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<{
+            claimableRoleIdentifier: z.ZodString;
+            top: z.ZodOptional<z.ZodNumber>;
+            skip: z.ZodOptional<z.ZodNumber>;
+            filter: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodObject<{
+            totalCount: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            count: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            nextPage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            prevPage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            value: z.ZodOptional<z.ZodArray<z.ZodType<{
+                id?: string | undefined;
+                assignedTo?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | undefined;
+                claimableRole?: {
+                    id?: string | undefined;
+                    name?: string | undefined;
+                    displayName?: string | undefined;
+                    description?: string | undefined;
+                    accessRoleMappings?: {
+                        accessRole?: {
+                            id?: string | undefined;
+                            name?: string | undefined;
+                            description?: string | undefined;
+                            scopeType?: {
+                                id?: string | undefined;
+                                name?: string | undefined;
+                                description?: string | null | undefined;
+                            } | null | undefined;
+                        } | undefined;
+                        reason?: string | null | undefined;
+                    }[] | null | undefined;
+                    system?: {
+                        id?: string | undefined;
+                        name?: string | undefined;
+                    } | null | undefined;
+                } | undefined;
+                source?: string | null | undefined;
+                externalIdentifier?: string | null | undefined;
+                reason?: string | undefined;
+                type?: string | undefined;
+                validFrom?: string | null | undefined;
+                validTo?: string | null | undefined;
+                isActive?: boolean | undefined;
+                activeTo?: string | null | undefined;
+                scope?: {
+                    isGlobal: boolean;
+                    value: string | null;
+                    scopeTypeIdentifier?: string | null | undefined;
+                } | null | undefined;
+                tags?: string[] | undefined;
+            }, unknown, z.core.$ZodTypeInternals<{
+                id?: string | undefined;
+                assignedTo?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | undefined;
+                claimableRole?: {
+                    id?: string | undefined;
+                    name?: string | undefined;
+                    displayName?: string | undefined;
+                    description?: string | undefined;
+                    accessRoleMappings?: {
+                        accessRole?: {
+                            id?: string | undefined;
+                            name?: string | undefined;
+                            description?: string | undefined;
+                            scopeType?: {
+                                id?: string | undefined;
+                                name?: string | undefined;
+                                description?: string | null | undefined;
+                            } | null | undefined;
+                        } | undefined;
+                        reason?: string | null | undefined;
+                    }[] | null | undefined;
+                    system?: {
+                        id?: string | undefined;
+                        name?: string | undefined;
+                    } | null | undefined;
+                } | undefined;
+                source?: string | null | undefined;
+                externalIdentifier?: string | null | undefined;
+                reason?: string | undefined;
+                type?: string | undefined;
+                validFrom?: string | null | undefined;
+                validTo?: string | null | undefined;
+                isActive?: boolean | undefined;
+                activeTo?: string | null | undefined;
+                scope?: {
+                    isGlobal: boolean;
+                    value: string | null;
+                    scopeTypeIdentifier?: string | null | undefined;
+                } | null | undefined;
+                tags?: string[] | undefined;
+            }, unknown>>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `listClaimableRoleAssignments` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiPagedCollectionV1<ApiClaimableRoleAssignmentV1>`, inferred from
+ * `apiPagedCollectionSchemaV1(ApiClaimableRoleAssignmentSchemaV1)` — the very schema that
+ * validates the `200 OK` body at runtime.
+ */
+type ListClaimableRoleAssignmentsResponse<TVersion extends ListClaimableRoleAssignmentsVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listClaimableRoleAssignments` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `claimableRoleIdentifier`, and the optional query
+ * options `top`, `skip`, `filter`.
+ *
+ * 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 ListClaimableRoleAssignmentsArg<TVersion extends ListClaimableRoleAssignmentsVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listClaimableRoleAssignments` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<ListClaimableRoleAssignmentsResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<ListClaimableRoleAssignmentsResponse<TVersion>>`, so promise and observable
+ * callers share one response type.
+ */
+type ListClaimableRoleAssignmentsResult<TVersion extends ListClaimableRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListClaimableRoleAssignmentsResponse<TVersion>>[TMethod];
+/**
+ * Lists the assignments of one claimable role.
+ *
+ * Roles V2 operation: `GET /claimable-roles/{claimableRoleIdentifier}/assignments` — "Get all
+ * claimable role assignments for a claimable role."
+ *
+ * Curried in two stages: `listClaimableRoleAssignments(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 ListClaimableRoleAssignmentsArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link ListClaimableRoleAssignmentsResult}.
+ *
+ * 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
+ * `apiPagedCollectionSchemaV1(ApiClaimableRoleAssignmentSchemaV1)`, and sends `api-version=1.0`
+ * on the request.
+ *
+ * Query options: `top` and `skip` page the collection as `$top` and `$skip` (`top` accepts
+ * 0–100); and `filter` is sent as an OData `$filter` expression.
+ *
+ * Roles V2 answers `200 OK`; the body is typed
+ * `ApiPagedCollectionV1<ApiClaimableRoleAssignmentV1>`.
+ *
+ * @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 ListClaimableRoleAssignmentsArg} and an optional
+ * `ClientRequestInit`, returning {@link ListClaimableRoleAssignmentsResult}.
+ * @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 { listClaimableRoleAssignments } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listClaimableRoleAssignments('v1', httpClient)({
+ *   claimableRoleIdentifier: 'on-call-approver',
+ *   top: 25,
+ * });
+ * ```
+ */
+declare const listClaimableRoleAssignments: <TVersion extends ListClaimableRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: ListClaimableRoleAssignmentsArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListClaimableRoleAssignmentsResponse<ExtractApiVersion<TVersion>>>) => ListClaimableRoleAssignmentsResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListClaimableRoleAssignmentsArg, type ListClaimableRoleAssignmentsResponse, type ListClaimableRoleAssignmentsResult, type ListClaimableRoleAssignmentsVersion, listClaimableRoleAssignments, };