@equinor/fusion-services 0.2.0

package/dist/types/roles/endpoints/claimable-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 `addClaimableRoleAccessRoles` accepts for
+ * `POST /claimable-roles/{claimableRoleIdentifier}/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 AddClaimableRoleAccessRolesArg} and {@link AddClaimableRoleAccessRolesResponse}.
+ */
+type AddClaimableRoleAccessRolesVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `addClaimableRoleAccessRoles`, implementing
+ * `POST /claimable-roles/{claimableRoleIdentifier}/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>>;
+            claimableRoleIdentifier: 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>;
+            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.ZodObject<{
+            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 `addClaimableRoleAccessRoles` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiClaimableRoleV1`, inferred from `ApiClaimableRoleSchemaV1` — the
+ * very schema that validates the `201 Created` body at runtime.
+ */
+type AddClaimableRoleAccessRolesResponse<TVersion extends AddClaimableRoleAccessRolesVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `addClaimableRoleAccessRoles` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `claimableRoleIdentifier`, and the request body
+ * fields of `AddClaimableRoleAccessRoleRequestV1`.
+ *
+ * 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 AddClaimableRoleAccessRolesArg<TVersion extends AddClaimableRoleAccessRolesVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `addClaimableRoleAccessRoles` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<AddClaimableRoleAccessRolesResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<AddClaimableRoleAccessRolesResponse<TVersion>>`, so promise and observable
+ * callers share one response type.
+ */
+type AddClaimableRoleAccessRolesResult<TVersion extends AddClaimableRoleAccessRolesVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<AddClaimableRoleAccessRolesResponse<TVersion>>[TMethod];
+/**
+ * Adds one or more access role mappings to a claimable role, so activating that claimable role
+ * grants the mapped access roles.
+ *
+ * Roles V2 operation: `POST /claimable-roles/{claimableRoleIdentifier}/access-roles` — "Add one
+ * or more access role mappings to a claimable role."
+ *
+ * Curried in two stages: `addClaimableRoleAccessRoles(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 AddClaimableRoleAccessRolesArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link AddClaimableRoleAccessRolesResult}.
+ *
+ * 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
+ * `ApiClaimableRoleSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `201 Created`; the body is typed `ApiClaimableRoleV1`. 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 AddClaimableRoleAccessRolesArg} and an optional
+ * `ClientRequestInit`, returning {@link AddClaimableRoleAccessRolesResult}.
+ * @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 { addClaimableRoleAccessRoles } from '@equinor/fusion-services/roles';
+ *
+ * const claimableRole = await addClaimableRoleAccessRoles('v1', httpClient)({
+ *   claimableRoleIdentifier: 'on-call-approver',
+ *   accessRoleMappings: [{ accessRoleIdentifier: 'writer' }],
+ * });
+ * ```
+ */
+declare const addClaimableRoleAccessRoles: <TVersion extends AddClaimableRoleAccessRolesVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: AddClaimableRoleAccessRolesArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, AddClaimableRoleAccessRolesResponse<ExtractApiVersion<TVersion>>>) => AddClaimableRoleAccessRolesResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type AddClaimableRoleAccessRolesArg, type AddClaimableRoleAccessRolesResponse, type AddClaimableRoleAccessRolesResult, type AddClaimableRoleAccessRolesVersion, addClaimableRoleAccessRoles, };

package/dist/types/roles/endpoints/claimable-role-assignment-activations-by-assignment.get.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 `listActivationsForClaimableRoleAssignment` accepts for
+ * `GET /claimable-roles/{claimableRoleIdentifier}/assignments/{claimableRoleAssignmentId}/activations`.
+ *
+ * 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 ListActivationsForClaimableRoleAssignmentArg} and
+ * {@link ListActivationsForClaimableRoleAssignmentResponse}.
+ */
+type ListActivationsForClaimableRoleAssignmentVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listActivationsForClaimableRoleAssignment`, implementing
+ * `GET /claimable-roles/{claimableRoleIdentifier}/assignments/{claimableRoleAssignmentId}/activations`.
+ *
+ * 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;
+            top: z.ZodOptional<z.ZodNumber>;
+            skip: z.ZodOptional<z.ZodNumber>;
+        }, 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;
+                activationDate?: string | undefined;
+                activeToDate?: string | undefined;
+                reason?: string | undefined;
+                activatedBy?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | undefined;
+            }, unknown, z.core.$ZodTypeInternals<{
+                id?: string | undefined;
+                activationDate?: string | undefined;
+                activeToDate?: string | undefined;
+                reason?: string | undefined;
+                activatedBy?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | undefined;
+            }, unknown>>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `listActivationsForClaimableRoleAssignment` resolves for the selected API
+ * version.
+ *
+ * Version 1.0 resolves to `ApiPagedCollectionV1<ApiClaimableRoleAssignmentActivationV1>`,
+ * inferred from `apiPagedCollectionSchemaV1(ApiClaimableRoleAssignmentActivationSchemaV1)` —
+ * the very schema that validates the `200 OK` body at runtime.
+ */
+type ListActivationsForClaimableRoleAssignmentResponse<TVersion extends ListActivationsForClaimableRoleAssignmentVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listActivationsForClaimableRoleAssignment` accepts, resolved from the selected API
+ * version.
+ *
+ * Version 1.0 accepts the path identifiers `claimableRoleIdentifier`,
+ * `claimableRoleAssignmentId`, and the optional query options `top`, `skip`.
+ *
+ * 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 ListActivationsForClaimableRoleAssignmentArg<TVersion extends ListActivationsForClaimableRoleAssignmentVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listActivationsForClaimableRoleAssignment` hands back once the request runs, for the
+ * selected API version and client method.
+ *
+ * `'json'` gives `Promise<ListActivationsForClaimableRoleAssignmentResponse<TVersion>>` and
+ * `'json$'` gives
+ * `StreamResponse<ListActivationsForClaimableRoleAssignmentResponse<TVersion>>`, so promise and
+ * observable callers share one response type.
+ */
+type ListActivationsForClaimableRoleAssignmentResult<TVersion extends ListActivationsForClaimableRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListActivationsForClaimableRoleAssignmentResponse<TVersion>>[TMethod];
+/**
+ * Lists every activation (every claim) recorded against one claimable role assignment.
+ *
+ * Roles V2 operation:
+ * `GET /claimable-roles/{claimableRoleIdentifier}/assignments/{claimableRoleAssignmentId}/activations`
+ * — "Get all activations for a claimable role assignment."
+ *
+ * Curried in two stages: `listActivationsForClaimableRoleAssignment(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 ListActivationsForClaimableRoleAssignmentArg} plus an optional
+ * `ClientRequestInit`, and gives back {@link ListActivationsForClaimableRoleAssignmentResult}.
+ *
+ * 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(ApiClaimableRoleAssignmentActivationSchemaV1)`, 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).
+ *
+ * Roles V2 answers `200 OK`; the body is typed
+ * `ApiPagedCollectionV1<ApiClaimableRoleAssignmentActivationV1>`.
+ *
+ * @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 ListActivationsForClaimableRoleAssignmentArg} and
+ * an optional `ClientRequestInit`, returning
+ * {@link ListActivationsForClaimableRoleAssignmentResult}.
+ * @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 { listActivationsForClaimableRoleAssignment } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listActivationsForClaimableRoleAssignment('v1', httpClient)({
+ *   claimableRoleIdentifier: 'on-call-approver',
+ *   claimableRoleAssignmentId: '6b1d4f2a-8c3e-4d59-9f70-1a2b3c4d5e6f',
+ *   top: 25,
+ * });
+ * ```
+ */
+declare const listActivationsForClaimableRoleAssignment: <TVersion extends ListActivationsForClaimableRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: ListActivationsForClaimableRoleAssignmentArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListActivationsForClaimableRoleAssignmentResponse<ExtractApiVersion<TVersion>>>) => ListActivationsForClaimableRoleAssignmentResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListActivationsForClaimableRoleAssignmentArg, type ListActivationsForClaimableRoleAssignmentResponse, type ListActivationsForClaimableRoleAssignmentResult, type ListActivationsForClaimableRoleAssignmentVersion, listActivationsForClaimableRoleAssignment, };

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

@@ -0,0 +1,187 @@
+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 `listClaimableRoleAssignmentActivations` accepts for
+ * `GET /claimable-role-assignment-activations`.
+ *
+ * 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 ListClaimableRoleAssignmentActivationsArg} and
+ * {@link ListClaimableRoleAssignmentActivationsResponse}.
+ */
+type ListClaimableRoleAssignmentActivationsVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listClaimableRoleAssignmentActivations`, implementing
+ * `GET /claimable-role-assignment-activations`.
+ *
+ * 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.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;
+                claimableRoleAssignment?: {
+                    id?: string | 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;
+                } | undefined;
+                activationDate?: string | undefined;
+                activeToDate?: string | undefined;
+                reason?: string | undefined;
+                activatedBy?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | undefined;
+            }, unknown, z.core.$ZodTypeInternals<{
+                id?: string | undefined;
+                claimableRoleAssignment?: {
+                    id?: string | 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;
+                } | undefined;
+                activationDate?: string | undefined;
+                activeToDate?: string | undefined;
+                reason?: string | undefined;
+                activatedBy?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | undefined;
+            }, unknown>>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `listClaimableRoleAssignmentActivations` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to
+ * `ApiPagedCollectionV1<ApiExtendedClaimableRoleAssignmentActivationV1>`, inferred from
+ * `apiPagedCollectionSchemaV1(ApiExtendedClaimableRoleAssignmentActivationSchemaV1)` — the very
+ * schema that validates the `200 OK` body at runtime.
+ */
+type ListClaimableRoleAssignmentActivationsResponse<TVersion extends ListClaimableRoleAssignmentActivationsVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listClaimableRoleAssignmentActivations` 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 ListClaimableRoleAssignmentActivationsArg<TVersion extends ListClaimableRoleAssignmentActivationsVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listClaimableRoleAssignmentActivations` hands back once the request runs, for the
+ * selected API version and client method.
+ *
+ * `'json'` gives `Promise<ListClaimableRoleAssignmentActivationsResponse<TVersion>>` and
+ * `'json$'` gives `StreamResponse<ListClaimableRoleAssignmentActivationsResponse<TVersion>>`,
+ * so promise and observable callers share one response type.
+ */
+type ListClaimableRoleAssignmentActivationsResult<TVersion extends ListClaimableRoleAssignmentActivationsVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListClaimableRoleAssignmentActivationsResponse<TVersion>>[TMethod];
+/**
+ * Lists claimable role assignment activations across the whole Roles service, not scoped to one
+ * role or account.
+ *
+ * Roles V2 operation: `GET /claimable-role-assignment-activations` — "Get all claimable role
+ * assignment activations across the system."
+ *
+ * Curried in two stages: `listClaimableRoleAssignmentActivations(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 ListClaimableRoleAssignmentActivationsArg} plus an optional `ClientRequestInit`,
+ * and gives back {@link ListClaimableRoleAssignmentActivationsResult}.
+ *
+ * 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(ApiExtendedClaimableRoleAssignmentActivationSchemaV1)`, and sends
+ * `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed
+ * `ApiPagedCollectionV1<ApiExtendedClaimableRoleAssignmentActivationV1>`.
+ *
+ * @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 ListClaimableRoleAssignmentActivationsArg} and an
+ * optional `ClientRequestInit`, returning {@link ListClaimableRoleAssignmentActivationsResult}.
+ * @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 { listClaimableRoleAssignmentActivations } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listClaimableRoleAssignmentActivations('v1', httpClient)({});
+ * ```
+ */
+declare const listClaimableRoleAssignmentActivations: <TVersion extends ListClaimableRoleAssignmentActivationsVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input?: ListClaimableRoleAssignmentActivationsArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListClaimableRoleAssignmentActivationsResponse<ExtractApiVersion<TVersion>>>) => ListClaimableRoleAssignmentActivationsResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListClaimableRoleAssignmentActivationsArg, type ListClaimableRoleAssignmentActivationsResponse, type ListClaimableRoleAssignmentActivationsResult, type ListClaimableRoleAssignmentActivationsVersion, listClaimableRoleAssignmentActivations, };

package/dist/types/roles/endpoints/claimable-role-assignment.delete.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 `deleteClaimableRoleAssignment` accepts for
+ * `DELETE /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 DeleteClaimableRoleAssignmentArg} and {@link DeleteClaimableRoleAssignmentResponse}.
+ */
+type DeleteClaimableRoleAssignmentVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `deleteClaimableRoleAssignment`, implementing
+ * `DELETE /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. The operation answers `204 No Content`. */
+        readonly response: z.ZodVoid;
+    };
+};
+/**
+ * Response body `deleteClaimableRoleAssignment` resolves for the selected API version.
+ *
+ * Version 1.0 answers `204 No Content` without a body, so the type resolves to `void`.
+ */
+type DeleteClaimableRoleAssignmentResponse<TVersion extends DeleteClaimableRoleAssignmentVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `deleteClaimableRoleAssignment` 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 DeleteClaimableRoleAssignmentArg<TVersion extends DeleteClaimableRoleAssignmentVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `deleteClaimableRoleAssignment` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<DeleteClaimableRoleAssignmentResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<DeleteClaimableRoleAssignmentResponse<TVersion>>`, so promise and observable
+ * callers share one response type.
+ */
+type DeleteClaimableRoleAssignmentResult<TVersion extends DeleteClaimableRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<DeleteClaimableRoleAssignmentResponse<TVersion>>[TMethod];
+/**
+ * Deletes one assignment of a claimable role, addressed by its assignment ID.
+ *
+ * Roles V2 operation:
+ * `DELETE /claimable-roles/{claimableRoleIdentifier}/assignments/{claimableRoleAssignmentId}` —
+ * "Delete a claimable role assignment by ID."
+ *
+ * Curried in two stages: `deleteClaimableRoleAssignment(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 DeleteClaimableRoleAssignmentArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link DeleteClaimableRoleAssignmentResult}.
+ *
+ * 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 claimable 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 DeleteClaimableRoleAssignmentArg} and an optional
+ * `ClientRequestInit`, returning {@link DeleteClaimableRoleAssignmentResult}.
+ * @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 { deleteClaimableRoleAssignment } from '@equinor/fusion-services/roles';
+ *
+ * await deleteClaimableRoleAssignment('v1', httpClient)({
+ *   claimableRoleIdentifier: 'on-call-approver',
+ *   claimableRoleAssignmentId: '6b1d4f2a-8c3e-4d59-9f70-1a2b3c4d5e6f',
+ * });
+ * ```
+ */
+declare const deleteClaimableRoleAssignment: <TVersion extends DeleteClaimableRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: DeleteClaimableRoleAssignmentArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, DeleteClaimableRoleAssignmentResponse<ExtractApiVersion<TVersion>>>) => DeleteClaimableRoleAssignmentResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type DeleteClaimableRoleAssignmentArg, type DeleteClaimableRoleAssignmentResponse, type DeleteClaimableRoleAssignmentResult, type DeleteClaimableRoleAssignmentVersion, deleteClaimableRoleAssignment, };