@equinor/fusion-services 0.2.0

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

@@ -0,0 +1,123 @@
+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 `getClaimableRoleAssignmentActivation` accepts for
+ * `GET /accounts/{accountIdentifier}/claimable-role-assignments/{claimableRoleAssignmentId}/activations/{claimableRoleAssignmentActivationId}`.
+ *
+ * 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 GetClaimableRoleAssignmentActivationArg} and
+ * {@link GetClaimableRoleAssignmentActivationResponse}.
+ */
+type GetClaimableRoleAssignmentActivationVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `getClaimableRoleAssignmentActivation`, implementing
+ * `GET /accounts/{accountIdentifier}/claimable-role-assignments/{claimableRoleAssignmentId}/activations/{claimableRoleAssignmentActivationId}`.
+ *
+ * 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.ZodString;
+            claimableRoleAssignmentId: z.ZodString;
+            claimableRoleAssignmentActivationId: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            activationDate: z.ZodOptional<z.ZodString>;
+            activeToDate: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            activatedBy: 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>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `getClaimableRoleAssignmentActivation` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiClaimableRoleAssignmentActivationV1`, inferred from
+ * `ApiClaimableRoleAssignmentActivationSchemaV1` — the very schema that validates the `200 OK`
+ * body at runtime.
+ */
+type GetClaimableRoleAssignmentActivationResponse<TVersion extends GetClaimableRoleAssignmentActivationVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `getClaimableRoleAssignmentActivation` accepts, resolved from the selected API
+ * version.
+ *
+ * Version 1.0 accepts the path identifiers `accountIdentifier`, `claimableRoleAssignmentId`,
+ * `claimableRoleAssignmentActivationId`.
+ *
+ * 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 GetClaimableRoleAssignmentActivationArg<TVersion extends GetClaimableRoleAssignmentActivationVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `getClaimableRoleAssignmentActivation` hands back once the request runs, for the
+ * selected API version and client method.
+ *
+ * `'json'` gives `Promise<GetClaimableRoleAssignmentActivationResponse<TVersion>>` and
+ * `'json$'` gives `StreamResponse<GetClaimableRoleAssignmentActivationResponse<TVersion>>`, so
+ * promise and observable callers share one response type.
+ */
+type GetClaimableRoleAssignmentActivationResult<TVersion extends GetClaimableRoleAssignmentActivationVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<GetClaimableRoleAssignmentActivationResponse<TVersion>>[TMethod];
+/**
+ * Fetches one activation (one claim) of an account's claimable role assignment, addressed by
+ * its activation ID.
+ *
+ * Roles V2 operation:
+ * `GET /accounts/{accountIdentifier}/claimable-role-assignments/{claimableRoleAssignmentId}/activations/{claimableRoleAssignmentActivationId}`
+ * — "Get a claimable role assignment activation by ID."
+ *
+ * Curried in two stages: `getClaimableRoleAssignmentActivation(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 GetClaimableRoleAssignmentActivationArg} plus an optional `ClientRequestInit`, and
+ * gives back {@link GetClaimableRoleAssignmentActivationResult}.
+ *
+ * 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
+ * `ApiClaimableRoleAssignmentActivationSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `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 GetClaimableRoleAssignmentActivationArg} and an
+ * optional `ClientRequestInit`, returning {@link GetClaimableRoleAssignmentActivationResult}.
+ * @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 { getClaimableRoleAssignmentActivation } from '@equinor/fusion-services/roles';
+ *
+ * const activation = await getClaimableRoleAssignmentActivation('v1', httpClient)({
+ *   accountIdentifier: 'user@equinor.com',
+ *   claimableRoleAssignmentId: '6b1d4f2a-8c3e-4d59-9f70-1a2b3c4d5e6f',
+ *   claimableRoleAssignmentActivationId: '9c7e2b10-4a5d-4f38-8b21-3e4f5a6b7c8d',
+ * });
+ * ```
+ */
+declare const getClaimableRoleAssignmentActivation: <TVersion extends GetClaimableRoleAssignmentActivationVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: GetClaimableRoleAssignmentActivationArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, GetClaimableRoleAssignmentActivationResponse<ExtractApiVersion<TVersion>>>) => GetClaimableRoleAssignmentActivationResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type GetClaimableRoleAssignmentActivationArg, type GetClaimableRoleAssignmentActivationResponse, type GetClaimableRoleAssignmentActivationResult, type GetClaimableRoleAssignmentActivationVersion, getClaimableRoleAssignmentActivation, };

package/dist/types/roles/endpoints/account-claimable-role-assignment-activation.post.d.ts

@@ -0,0 +1,127 @@
+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 `activateClaimableRoleAssignment` accepts for
+ * `POST /accounts/{accountIdentifier}/claimable-role-assignments/{claimableRoleAssignmentId}/activate`.
+ *
+ * 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 ActivateClaimableRoleAssignmentArg} and
+ * {@link ActivateClaimableRoleAssignmentResponse}.
+ */
+type ActivateClaimableRoleAssignmentVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `activateClaimableRoleAssignment`, implementing
+ * `POST /accounts/{accountIdentifier}/claimable-role-assignments/{claimableRoleAssignmentId}/activate`.
+ *
+ * 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<{
+            reason: z.ZodOptional<z.ZodString>;
+            hours: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            accountIdentifier: 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>;
+            activationDate: z.ZodOptional<z.ZodString>;
+            activeToDate: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            activatedBy: 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>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `activateClaimableRoleAssignment` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiClaimableRoleAssignmentActivationV1`, inferred from
+ * `ApiClaimableRoleAssignmentActivationSchemaV1` — the very schema that validates the `201
+ * Created` body at runtime.
+ */
+type ActivateClaimableRoleAssignmentResponse<TVersion extends ActivateClaimableRoleAssignmentVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `activateClaimableRoleAssignment` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifiers `accountIdentifier`, `claimableRoleAssignmentId`,
+ * and the request body fields of `ActivateAssignedClaimableRoleRequestV1`.
+ *
+ * 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 ActivateClaimableRoleAssignmentArg<TVersion extends ActivateClaimableRoleAssignmentVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `activateClaimableRoleAssignment` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<ActivateClaimableRoleAssignmentResponse<TVersion>>` and `'json$'`
+ * gives `StreamResponse<ActivateClaimableRoleAssignmentResponse<TVersion>>`, so promise and
+ * observable callers share one response type.
+ */
+type ActivateClaimableRoleAssignmentResult<TVersion extends ActivateClaimableRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ActivateClaimableRoleAssignmentResponse<TVersion>>[TMethod];
+/**
+ * Claims (activates) a claimable role assignment on behalf of a Fusion account, turning a role
+ * the account is eligible for into a time-boxed, active assignment.
+ *
+ * Roles V2 operation:
+ * `POST /accounts/{accountIdentifier}/claimable-role-assignments/{claimableRoleAssignmentId}/activate`
+ * — "Activate a claimable role assignment for an account."
+ *
+ * Curried in two stages: `activateClaimableRoleAssignment(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 ActivateClaimableRoleAssignmentArg} plus an optional `ClientRequestInit`, and gives
+ * back {@link ActivateClaimableRoleAssignmentResult}.
+ *
+ * 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
+ * `ApiClaimableRoleAssignmentActivationSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `201 Created`; the body is typed `ApiClaimableRoleAssignmentActivationV1`.
+ * 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 ActivateClaimableRoleAssignmentArg} and an optional
+ * `ClientRequestInit`, returning {@link ActivateClaimableRoleAssignmentResult}.
+ * @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 { activateClaimableRoleAssignment } from '@equinor/fusion-services/roles';
+ *
+ * const activation = await activateClaimableRoleAssignment('v1', httpClient)({
+ *   accountIdentifier: 'user@equinor.com',
+ *   claimableRoleAssignmentId: '6b1d4f2a-8c3e-4d59-9f70-1a2b3c4d5e6f',
+ *   reason: 'on-call incident 4471',
+ *   hours: 8,
+ * });
+ * ```
+ */
+declare const activateClaimableRoleAssignment: <TVersion extends ActivateClaimableRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: ActivateClaimableRoleAssignmentArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ActivateClaimableRoleAssignmentResponse<ExtractApiVersion<TVersion>>>) => ActivateClaimableRoleAssignmentResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ActivateClaimableRoleAssignmentArg, type ActivateClaimableRoleAssignmentResponse, type ActivateClaimableRoleAssignmentResult, type ActivateClaimableRoleAssignmentVersion, activateClaimableRoleAssignment, };

package/dist/types/roles/endpoints/account-claimable-role-assignment-deactivation.post.d.ts

@@ -0,0 +1,123 @@
+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 `deactivateClaimableRoleAssignment` accepts for
+ * `POST /accounts/{accountIdentifier}/claimable-role-assignments/{claimableRoleAssignmentId}/deactivate`.
+ *
+ * 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 DeactivateClaimableRoleAssignmentArg} and
+ * {@link DeactivateClaimableRoleAssignmentResponse}.
+ */
+type DeactivateClaimableRoleAssignmentVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `deactivateClaimableRoleAssignment`, implementing
+ * `POST /accounts/{accountIdentifier}/claimable-role-assignments/{claimableRoleAssignmentId}/deactivate`.
+ *
+ * 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.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>;
+            activationDate: z.ZodOptional<z.ZodString>;
+            activeToDate: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            activatedBy: 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>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `deactivateClaimableRoleAssignment` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiClaimableRoleAssignmentActivationV1`, inferred from
+ * `ApiClaimableRoleAssignmentActivationSchemaV1` — the very schema that validates the `201
+ * Created` body at runtime.
+ */
+type DeactivateClaimableRoleAssignmentResponse<TVersion extends DeactivateClaimableRoleAssignmentVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `deactivateClaimableRoleAssignment` accepts, resolved from the selected API
+ * version.
+ *
+ * Version 1.0 accepts the path identifiers `accountIdentifier`, `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 DeactivateClaimableRoleAssignmentArg<TVersion extends DeactivateClaimableRoleAssignmentVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `deactivateClaimableRoleAssignment` hands back once the request runs, for the selected
+ * API version and client method.
+ *
+ * `'json'` gives `Promise<DeactivateClaimableRoleAssignmentResponse<TVersion>>` and `'json$'`
+ * gives `StreamResponse<DeactivateClaimableRoleAssignmentResponse<TVersion>>`, so promise and
+ * observable callers share one response type.
+ */
+type DeactivateClaimableRoleAssignmentResult<TVersion extends DeactivateClaimableRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<DeactivateClaimableRoleAssignmentResponse<TVersion>>[TMethod];
+/**
+ * Ends an active claim early: deactivates a claimable role assignment for an account by setting
+ * its expiration to now.
+ *
+ * Roles V2 operation:
+ * `POST /accounts/{accountIdentifier}/claimable-role-assignments/{claimableRoleAssignmentId}/deactivate`
+ * — "Deactivate a claimable role assignment for an account by setting the expiration date to
+ * now."
+ *
+ * Curried in two stages: `deactivateClaimableRoleAssignment(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 DeactivateClaimableRoleAssignmentArg} plus an optional `ClientRequestInit`, and gives
+ * back {@link DeactivateClaimableRoleAssignmentResult}.
+ *
+ * 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
+ * `ApiClaimableRoleAssignmentActivationSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `201 Created`; the body is typed `ApiClaimableRoleAssignmentActivationV1`.
+ * 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 DeactivateClaimableRoleAssignmentArg} and an
+ * optional `ClientRequestInit`, returning {@link DeactivateClaimableRoleAssignmentResult}.
+ * @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 { deactivateClaimableRoleAssignment } from '@equinor/fusion-services/roles';
+ *
+ * const activation = await deactivateClaimableRoleAssignment('v1', httpClient)({
+ *   accountIdentifier: 'user@equinor.com',
+ *   claimableRoleAssignmentId: '6b1d4f2a-8c3e-4d59-9f70-1a2b3c4d5e6f',
+ * });
+ * ```
+ */
+declare const deactivateClaimableRoleAssignment: <TVersion extends DeactivateClaimableRoleAssignmentVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: DeactivateClaimableRoleAssignmentArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, DeactivateClaimableRoleAssignmentResponse<ExtractApiVersion<TVersion>>>) => DeactivateClaimableRoleAssignmentResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type DeactivateClaimableRoleAssignmentArg, type DeactivateClaimableRoleAssignmentResponse, type DeactivateClaimableRoleAssignmentResult, type DeactivateClaimableRoleAssignmentVersion, deactivateClaimableRoleAssignment, };

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

@@ -0,0 +1,230 @@
+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 `listAccountClaimableRoleAssignments` accepts for
+ * `GET /accounts/{accountIdentifier}/claimable-role-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 ListAccountClaimableRoleAssignmentsArg} and
+ * {@link ListAccountClaimableRoleAssignmentsResponse}.
+ */
+type ListAccountClaimableRoleAssignmentsVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listAccountClaimableRoleAssignments`, implementing
+ * `GET /accounts/{accountIdentifier}/claimable-role-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.ZodString;
+            expand: 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;
+            } & {
+                createdBy?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | undefined;
+                createdDate?: 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;
+            } & {
+                createdBy?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | undefined;
+                createdDate?: string | undefined;
+            }, unknown>>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `listAccountClaimableRoleAssignments` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiPagedCollectionV1<ApiAccountClaimableRoleAssignmentV1>`, inferred
+ * from `apiPagedCollectionSchemaV1(ApiAccountClaimableRoleAssignmentSchemaV1)` — the very
+ * schema that validates the `200 OK` body at runtime.
+ */
+type ListAccountClaimableRoleAssignmentsResponse<TVersion extends ListAccountClaimableRoleAssignmentsVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listAccountClaimableRoleAssignments` accepts, resolved from the selected API
+ * version.
+ *
+ * Version 1.0 accepts the path identifier `accountIdentifier`, and the optional query options
+ * `expand`.
+ *
+ * The value is parsed by the version's Zod argument schema before the request path is built, so
+ * defaults and range checks apply up front.
+ */
+type ListAccountClaimableRoleAssignmentsArg<TVersion extends ListAccountClaimableRoleAssignmentsVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listAccountClaimableRoleAssignments` hands back once the request runs, for the selected
+ * API version and client method.
+ *
+ * `'json'` gives `Promise<ListAccountClaimableRoleAssignmentsResponse<TVersion>>` and `'json$'`
+ * gives `StreamResponse<ListAccountClaimableRoleAssignmentsResponse<TVersion>>`, so promise and
+ * observable callers share one response type.
+ */
+type ListAccountClaimableRoleAssignmentsResult<TVersion extends ListAccountClaimableRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListAccountClaimableRoleAssignmentsResponse<TVersion>>[TMethod];
+/**
+ * Lists the claimable role assignments granted to one account, that is, the roles that account
+ * may claim.
+ *
+ * Roles V2 operation: `GET /accounts/{accountIdentifier}/claimable-role-assignments` — "Get all
+ * claimable role assignments for an account."
+ *
+ * Curried in two stages: `listAccountClaimableRoleAssignments(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 ListAccountClaimableRoleAssignmentsArg} plus an optional `ClientRequestInit`, and
+ * gives back {@link ListAccountClaimableRoleAssignmentsResult}.
+ *
+ * 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(ApiAccountClaimableRoleAssignmentSchemaV1)`, and sends
+ * `api-version=1.0` on the request.
+ *
+ * Query options: `expand` is sent as `$expand` to inline related resources.
+ *
+ * Roles V2 answers `200 OK`; the body is typed
+ * `ApiPagedCollectionV1<ApiAccountClaimableRoleAssignmentV1>`.
+ *
+ * @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 ListAccountClaimableRoleAssignmentsArg} and an
+ * optional `ClientRequestInit`, returning {@link ListAccountClaimableRoleAssignmentsResult}.
+ * @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 { listAccountClaimableRoleAssignments } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listAccountClaimableRoleAssignments('v1', httpClient)({
+ *   accountIdentifier: 'user@equinor.com',
+ * });
+ * ```
+ */
+declare const listAccountClaimableRoleAssignments: <TVersion extends ListAccountClaimableRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: ListAccountClaimableRoleAssignmentsArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListAccountClaimableRoleAssignmentsResponse<ExtractApiVersion<TVersion>>>) => ListAccountClaimableRoleAssignmentsResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListAccountClaimableRoleAssignmentsArg, type ListAccountClaimableRoleAssignmentsResponse, type ListAccountClaimableRoleAssignmentsResult, type ListAccountClaimableRoleAssignmentsVersion, listAccountClaimableRoleAssignments, };