@equinor/fusion-services 0.2.0

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

@@ -0,0 +1,168 @@
+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 `assignClaimableRole` accepts for
+ * `POST /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 AssignClaimableRoleArg} and {@link AssignClaimableRoleResponse}.
+ */
+type AssignClaimableRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `assignClaimableRole`, implementing
+ * `POST /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<{
+            accountIdentifier: z.ZodOptional<z.ZodString>;
+            source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            externalIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            reason: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            scope: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                scopeTypeIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                isGlobal: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                value: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+            validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            validTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            claimableRoleIdentifier: 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 `assignClaimableRole` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiClaimableRoleAssignmentV1`, inferred from
+ * `ApiClaimableRoleAssignmentSchemaV1` — the very schema that validates the `201 Created` body
+ * at runtime.
+ */
+type AssignClaimableRoleResponse<TVersion extends AssignClaimableRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `assignClaimableRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `claimableRoleIdentifier`, and the request body
+ * fields of `AssignClaimableRoleRequestV1`.
+ *
+ * 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 AssignClaimableRoleArg<TVersion extends AssignClaimableRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `assignClaimableRole` hands back once the request runs, for the selected API version and
+ * client method.
+ *
+ * `'json'` gives `Promise<AssignClaimableRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<AssignClaimableRoleResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type AssignClaimableRoleResult<TVersion extends AssignClaimableRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<AssignClaimableRoleResponse<TVersion>>[TMethod];
+/**
+ * Assigns a claimable role to a user or application, making the role available for that account
+ * to claim later.
+ *
+ * Roles V2 operation: `POST /claimable-roles/{claimableRoleIdentifier}/assignments` — "Assign a
+ * claimable role to a user or application."
+ *
+ * Curried in two stages: `assignClaimableRole(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 AssignClaimableRoleArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link AssignClaimableRoleResult}.
+ *
+ * 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 `201 Created`; the body is typed `ApiClaimableRoleAssignmentV1`. 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 AssignClaimableRoleArg} and an optional
+ * `ClientRequestInit`, returning {@link AssignClaimableRoleResult}.
+ * @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 { assignClaimableRole } from '@equinor/fusion-services/roles';
+ *
+ * const assignment = await assignClaimableRole('v1', httpClient)({
+ *   claimableRoleIdentifier: 'on-call-approver',
+ *   accountIdentifier: 'user@equinor.com',
+ *   reason: 'on-call rotation',
+ * });
+ * ```
+ */
+declare const assignClaimableRole: <TVersion extends AssignClaimableRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: AssignClaimableRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, AssignClaimableRoleResponse<ExtractApiVersion<TVersion>>>) => AssignClaimableRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type AssignClaimableRoleArg, type AssignClaimableRoleResponse, type AssignClaimableRoleResult, type AssignClaimableRoleVersion, assignClaimableRole, };

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

@@ -0,0 +1,100 @@
+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 `deleteClaimableRole` accepts for
+ * `DELETE /claimable-roles/{claimableRoleIdentifier}`.
+ *
+ * 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 DeleteClaimableRoleArg} and {@link DeleteClaimableRoleResponse}.
+ */
+type DeleteClaimableRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `deleteClaimableRole`, implementing
+ * `DELETE /claimable-roles/{claimableRoleIdentifier}`.
+ *
+ * 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;
+        }, z.core.$strip>;
+        /** Response published by version 1.0. The operation answers `204 No Content`. */
+        readonly response: z.ZodVoid;
+    };
+};
+/**
+ * Response body `deleteClaimableRole` resolves for the selected API version.
+ *
+ * Version 1.0 answers `204 No Content` without a body, so the type resolves to `void`.
+ */
+type DeleteClaimableRoleResponse<TVersion extends DeleteClaimableRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `deleteClaimableRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `claimableRoleIdentifier`.
+ *
+ * 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 DeleteClaimableRoleArg<TVersion extends DeleteClaimableRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `deleteClaimableRole` hands back once the request runs, for the selected API version and
+ * client method.
+ *
+ * `'json'` gives `Promise<DeleteClaimableRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<DeleteClaimableRoleResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type DeleteClaimableRoleResult<TVersion extends DeleteClaimableRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<DeleteClaimableRoleResponse<TVersion>>[TMethod];
+/**
+ * Deletes a claimable role, addressed by its UUID or unique name.
+ *
+ * Roles V2 operation: `DELETE /claimable-roles/{claimableRoleIdentifier}` — "Delete a claimable
+ * role by identifier."
+ *
+ * Curried in two stages: `deleteClaimableRole(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 DeleteClaimableRoleArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link DeleteClaimableRoleResult}.
+ *
+ * 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 and its assignments 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 DeleteClaimableRoleArg} and an optional
+ * `ClientRequestInit`, returning {@link DeleteClaimableRoleResult}.
+ * @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 { deleteClaimableRole } from '@equinor/fusion-services/roles';
+ *
+ * await deleteClaimableRole('v1', httpClient)({ claimableRoleIdentifier: 'on-call-approver' });
+ * ```
+ */
+declare const deleteClaimableRole: <TVersion extends DeleteClaimableRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: DeleteClaimableRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, DeleteClaimableRoleResponse<ExtractApiVersion<TVersion>>>) => DeleteClaimableRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type DeleteClaimableRoleArg, type DeleteClaimableRoleResponse, type DeleteClaimableRoleResult, type DeleteClaimableRoleVersion, deleteClaimableRole, };

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

@@ -0,0 +1,141 @@
+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 `getClaimableRole` accepts for
+ * `GET /claimable-roles/{claimableRoleIdentifier}`.
+ *
+ * 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 GetClaimableRoleArg} and {@link GetClaimableRoleResponse}.
+ */
+type GetClaimableRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `getClaimableRole`, implementing
+ * `GET /claimable-roles/{claimableRoleIdentifier}`.
+ *
+ * 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;
+        }, 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 `getClaimableRole` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiClaimableRoleV1`, inferred from `ApiClaimableRoleSchemaV1` — the
+ * very schema that validates the `200 OK` body at runtime.
+ */
+type GetClaimableRoleResponse<TVersion extends GetClaimableRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `getClaimableRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `claimableRoleIdentifier`.
+ *
+ * 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 GetClaimableRoleArg<TVersion extends GetClaimableRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `getClaimableRole` hands back once the request runs, for the selected API version and
+ * client method.
+ *
+ * `'json'` gives `Promise<GetClaimableRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<GetClaimableRoleResponse<TVersion>>`, so promise and observable callers share
+ * one response type.
+ */
+type GetClaimableRoleResult<TVersion extends GetClaimableRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<GetClaimableRoleResponse<TVersion>>[TMethod];
+/**
+ * Fetches one claimable role by its UUID or unique claimable role name.
+ *
+ * Roles V2 operation: `GET /claimable-roles/{claimableRoleIdentifier}` — "Get a claimable role
+ * by identifier."
+ *
+ * Curried in two stages: `getClaimableRole(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 GetClaimableRoleArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link GetClaimableRoleResult}.
+ *
+ * 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 `200 OK`; the body is typed `ApiClaimableRoleV1`.
+ *
+ * @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 GetClaimableRoleArg} and an optional
+ * `ClientRequestInit`, returning {@link GetClaimableRoleResult}.
+ * @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 { getClaimableRole } from '@equinor/fusion-services/roles';
+ *
+ * const claimableRole = await getClaimableRole('v1', httpClient)({
+ *   claimableRoleIdentifier: 'on-call-approver',
+ * });
+ * ```
+ */
+declare const getClaimableRole: <TVersion extends GetClaimableRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: GetClaimableRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, GetClaimableRoleResponse<ExtractApiVersion<TVersion>>>) => GetClaimableRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type GetClaimableRoleArg, type GetClaimableRoleResponse, type GetClaimableRoleResult, type GetClaimableRoleVersion, getClaimableRole, };

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

@@ -0,0 +1,149 @@
+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 `updateClaimableRole` accepts for
+ * `PATCH /claimable-roles/{claimableRoleIdentifier}`.
+ *
+ * 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 UpdateClaimableRoleArg} and {@link UpdateClaimableRoleResponse}.
+ */
+type UpdateClaimableRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `updateClaimableRole`, implementing
+ * `PATCH /claimable-roles/{claimableRoleIdentifier}`.
+ *
+ * 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<{
+            displayName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            systemIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            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 `updateClaimableRole` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiClaimableRoleV1`, inferred from `ApiClaimableRoleSchemaV1` — the
+ * very schema that validates the `200 OK` body at runtime.
+ */
+type UpdateClaimableRoleResponse<TVersion extends UpdateClaimableRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `updateClaimableRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `claimableRoleIdentifier`, and the request body
+ * fields of `UpdateClaimableRoleRequestV1`.
+ *
+ * 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 UpdateClaimableRoleArg<TVersion extends UpdateClaimableRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `updateClaimableRole` hands back once the request runs, for the selected API version and
+ * client method.
+ *
+ * `'json'` gives `Promise<UpdateClaimableRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<UpdateClaimableRoleResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type UpdateClaimableRoleResult<TVersion extends UpdateClaimableRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<UpdateClaimableRoleResponse<TVersion>>[TMethod];
+/**
+ * Updates the display name, description, or owning system of a claimable role.
+ *
+ * Roles V2 operation: `PATCH /claimable-roles/{claimableRoleIdentifier}` — "Update a claimable
+ * role by identifier."
+ *
+ * Curried in two stages: `updateClaimableRole(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 UpdateClaimableRoleArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link UpdateClaimableRoleResult}.
+ *
+ * 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 `200 OK`; the body is typed `ApiClaimableRoleV1`. 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 UpdateClaimableRoleArg} and an optional
+ * `ClientRequestInit`, returning {@link UpdateClaimableRoleResult}.
+ * @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 { updateClaimableRole } from '@equinor/fusion-services/roles';
+ *
+ * const claimableRole = await updateClaimableRole('v1', httpClient)({
+ *   claimableRoleIdentifier: 'on-call-approver',
+ *   description: 'Approves on-call claims',
+ * });
+ * ```
+ */
+declare const updateClaimableRole: <TVersion extends UpdateClaimableRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: UpdateClaimableRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, UpdateClaimableRoleResponse<ExtractApiVersion<TVersion>>>) => UpdateClaimableRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type UpdateClaimableRoleArg, type UpdateClaimableRoleResponse, type UpdateClaimableRoleResult, type UpdateClaimableRoleVersion, updateClaimableRole, };