@equinor/fusion-services 0.2.0

package/dist/types/roles/endpoints/account-consolidated-claimable-role-assignments.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 `listAccountConsolidatedClaimableRoleAssignments` accepts for
+ * `GET /accounts/{accountIdentifier}/consolidated-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 ListAccountConsolidatedClaimableRoleAssignmentsArg} and
+ * {@link ListAccountConsolidatedClaimableRoleAssignmentsResponse}.
+ */
+type ListAccountConsolidatedClaimableRoleAssignmentsVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listAccountConsolidatedClaimableRoleAssignments`, implementing
+ * `GET /accounts/{accountIdentifier}/consolidated-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.ZodArray<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>;
+            }, z.core.$strip>>;
+            reasons: z.ZodOptional<z.ZodArray<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>>>;
+            assignments: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                validTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                reason: z.ZodOptional<z.ZodString>;
+                source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                externalIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>>;
+    };
+};
+/**
+ * Response body `listAccountConsolidatedClaimableRoleAssignments` resolves for the selected API
+ * version.
+ *
+ * Version 1.0 resolves to `ApiConsolidatedClaimableRoleAssignmentV1[]`, inferred from
+ * `z.array(ApiConsolidatedClaimableRoleAssignmentSchemaV1)` — the very schema that validates
+ * the `200 OK` body at runtime.
+ */
+type ListAccountConsolidatedClaimableRoleAssignmentsResponse<TVersion extends ListAccountConsolidatedClaimableRoleAssignmentsVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listAccountConsolidatedClaimableRoleAssignments` 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 ListAccountConsolidatedClaimableRoleAssignmentsArg<TVersion extends ListAccountConsolidatedClaimableRoleAssignmentsVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listAccountConsolidatedClaimableRoleAssignments` hands back once the request runs, for
+ * the selected API version and client method.
+ *
+ * `'json'` gives `Promise<ListAccountConsolidatedClaimableRoleAssignmentsResponse<TVersion>>`
+ * and `'json$'` gives
+ * `StreamResponse<ListAccountConsolidatedClaimableRoleAssignmentsResponse<TVersion>>`, so
+ * promise and observable callers share one response type.
+ */
+type ListAccountConsolidatedClaimableRoleAssignmentsResult<TVersion extends ListAccountConsolidatedClaimableRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListAccountConsolidatedClaimableRoleAssignmentsResponse<TVersion>>[TMethod];
+/**
+ * Lists one account's claimable role assignments consolidated, merging duplicates that share
+ * role, type, and scope into a single entry.
+ *
+ * Roles V2 operation:
+ * `GET /accounts/{accountIdentifier}/consolidated-claimable-role-assignments` — "Get
+ * consolidated claimable role assignments for an account. Duplicate assignments for the same
+ * role, type and scope are merged into a single entry."
+ *
+ * Curried in two stages: `listAccountConsolidatedClaimableRoleAssignments(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 ListAccountConsolidatedClaimableRoleAssignmentsArg} plus an optional
+ * `ClientRequestInit`, and gives back
+ * {@link ListAccountConsolidatedClaimableRoleAssignmentsResult}.
+ *
+ * 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
+ * `z.array(ApiConsolidatedClaimableRoleAssignmentSchemaV1)`, 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 `ApiConsolidatedClaimableRoleAssignmentV1[]`.
+ *
+ * @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 ListAccountConsolidatedClaimableRoleAssignmentsArg}
+ * and an optional `ClientRequestInit`, returning
+ * {@link ListAccountConsolidatedClaimableRoleAssignmentsResult}.
+ * @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 { listAccountConsolidatedClaimableRoleAssignments } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listAccountConsolidatedClaimableRoleAssignments('v1', httpClient)({
+ *   accountIdentifier: 'user@equinor.com',
+ * });
+ * ```
+ */
+declare const listAccountConsolidatedClaimableRoleAssignments: <TVersion extends ListAccountConsolidatedClaimableRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: ListAccountConsolidatedClaimableRoleAssignmentsArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListAccountConsolidatedClaimableRoleAssignmentsResponse<ExtractApiVersion<TVersion>>>) => ListAccountConsolidatedClaimableRoleAssignmentsResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListAccountConsolidatedClaimableRoleAssignmentsArg, type ListAccountConsolidatedClaimableRoleAssignmentsResponse, type ListAccountConsolidatedClaimableRoleAssignmentsResult, type ListAccountConsolidatedClaimableRoleAssignmentsVersion, listAccountConsolidatedClaimableRoleAssignments, };

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

@@ -0,0 +1,146 @@
+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 `listAccountConsolidatedRoleAssignments` accepts for
+ * `GET /accounts/{accountIdentifier}/consolidated-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 ListAccountConsolidatedRoleAssignmentsArg} and
+ * {@link ListAccountConsolidatedRoleAssignmentsResponse}.
+ */
+type ListAccountConsolidatedRoleAssignmentsVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listAccountConsolidatedRoleAssignments`, implementing
+ * `GET /accounts/{accountIdentifier}/consolidated-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.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            assignedTo: z.ZodOptional<z.ZodObject<{
+                azureUniqueId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                mail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                displayName: z.ZodOptional<z.ZodString>;
+                upn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                accountType: z.ZodOptional<z.ZodString>;
+                accountClassification: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+            role: z.ZodOptional<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+                displayName: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                system: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            reasons: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            type: z.ZodOptional<z.ZodString>;
+            validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            validTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            scope: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                isGlobal: z.ZodBoolean;
+                value: z.ZodNullable<z.ZodString>;
+                scopeTypeIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+            assignments: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                validFrom: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                validTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                reason: z.ZodOptional<z.ZodString>;
+                source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                externalIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>>;
+    };
+};
+/**
+ * Response body `listAccountConsolidatedRoleAssignments` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiConsolidatedRoleAssignmentV1[]`, inferred from
+ * `z.array(ApiConsolidatedRoleAssignmentSchemaV1)` — the very schema that validates the `200
+ * OK` body at runtime.
+ */
+type ListAccountConsolidatedRoleAssignmentsResponse<TVersion extends ListAccountConsolidatedRoleAssignmentsVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listAccountConsolidatedRoleAssignments` 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 ListAccountConsolidatedRoleAssignmentsArg<TVersion extends ListAccountConsolidatedRoleAssignmentsVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listAccountConsolidatedRoleAssignments` hands back once the request runs, for the
+ * selected API version and client method.
+ *
+ * `'json'` gives `Promise<ListAccountConsolidatedRoleAssignmentsResponse<TVersion>>` and
+ * `'json$'` gives `StreamResponse<ListAccountConsolidatedRoleAssignmentsResponse<TVersion>>`,
+ * so promise and observable callers share one response type.
+ */
+type ListAccountConsolidatedRoleAssignmentsResult<TVersion extends ListAccountConsolidatedRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListAccountConsolidatedRoleAssignmentsResponse<TVersion>>[TMethod];
+/**
+ * Lists one account's role assignments consolidated, merging duplicates that share role, type,
+ * and scope into a single entry.
+ *
+ * Roles V2 operation: `GET /accounts/{accountIdentifier}/consolidated-role-assignments` — "Get
+ * consolidated role assignments for an account. Duplicate assignments for the same role, type
+ * and scope are merged into a single entry."
+ *
+ * Curried in two stages: `listAccountConsolidatedRoleAssignments(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 ListAccountConsolidatedRoleAssignmentsArg} plus an optional `ClientRequestInit`,
+ * and gives back {@link ListAccountConsolidatedRoleAssignmentsResult}.
+ *
+ * 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
+ * `z.array(ApiConsolidatedRoleAssignmentSchemaV1)`, 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 `ApiConsolidatedRoleAssignmentV1[]`.
+ *
+ * @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 ListAccountConsolidatedRoleAssignmentsArg} and an
+ * optional `ClientRequestInit`, returning {@link ListAccountConsolidatedRoleAssignmentsResult}.
+ * @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 { listAccountConsolidatedRoleAssignments } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listAccountConsolidatedRoleAssignments('v1', httpClient)({
+ *   accountIdentifier: 'user@equinor.com',
+ * });
+ * ```
+ */
+declare const listAccountConsolidatedRoleAssignments: <TVersion extends ListAccountConsolidatedRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: ListAccountConsolidatedRoleAssignmentsArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListAccountConsolidatedRoleAssignmentsResponse<ExtractApiVersion<TVersion>>>) => ListAccountConsolidatedRoleAssignmentsResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListAccountConsolidatedRoleAssignmentsArg, type ListAccountConsolidatedRoleAssignmentsResponse, type ListAccountConsolidatedRoleAssignmentsResult, type ListAccountConsolidatedRoleAssignmentsVersion, listAccountConsolidatedRoleAssignments, };

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

@@ -0,0 +1,197 @@
+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 `listAccountRoleAssignments` accepts for
+ * `GET /accounts/{accountIdentifier}/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 ListAccountRoleAssignmentsArg} and {@link ListAccountRoleAssignmentsResponse}.
+ */
+type ListAccountRoleAssignmentsVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listAccountRoleAssignments`, implementing
+ * `GET /accounts/{accountIdentifier}/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;
+        }, 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;
+                role?: {
+                    id?: string | undefined;
+                    name?: string | undefined;
+                    displayName?: string | undefined;
+                    description?: string | 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;
+                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;
+                role?: {
+                    id?: string | undefined;
+                    name?: string | undefined;
+                    displayName?: string | undefined;
+                    description?: string | 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;
+                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 `listAccountRoleAssignments` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiPagedCollectionV1<ApiAccountRoleAssignmentV1>`, inferred from
+ * `apiPagedCollectionSchemaV1(ApiAccountRoleAssignmentSchemaV1)` — the very schema that
+ * validates the `200 OK` body at runtime.
+ */
+type ListAccountRoleAssignmentsResponse<TVersion extends ListAccountRoleAssignmentsVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listAccountRoleAssignments` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `accountIdentifier`.
+ *
+ * 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 ListAccountRoleAssignmentsArg<TVersion extends ListAccountRoleAssignmentsVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listAccountRoleAssignments` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<ListAccountRoleAssignmentsResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<ListAccountRoleAssignmentsResponse<TVersion>>`, so promise and observable
+ * callers share one response type.
+ */
+type ListAccountRoleAssignmentsResult<TVersion extends ListAccountRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListAccountRoleAssignmentsResponse<TVersion>>[TMethod];
+/**
+ * Lists all role assignments held by one account, whether that account is a user or an
+ * application.
+ *
+ * Roles V2 operation: `GET /accounts/{accountIdentifier}/role-assignments` — "Get all role
+ * assignments for an account."
+ *
+ * Curried in two stages: `listAccountRoleAssignments(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 ListAccountRoleAssignmentsArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link ListAccountRoleAssignmentsResult}.
+ *
+ * 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(ApiAccountRoleAssignmentSchemaV1)`, and sends `api-version=1.0`
+ * on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed
+ * `ApiPagedCollectionV1<ApiAccountRoleAssignmentV1>`.
+ *
+ * Related: `listAccountConsolidatedRoleAssignments` merges duplicates, and `getRole` fetches
+ * the role behind an assignment.
+ *
+ * @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 ListAccountRoleAssignmentsArg} and an optional
+ * `ClientRequestInit`, returning {@link ListAccountRoleAssignmentsResult}.
+ * @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 { listAccountRoleAssignments } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listAccountRoleAssignments('v1', httpClient)({
+ *   accountIdentifier: 'user@equinor.com',
+ * });
+ * ```
+ */
+declare const listAccountRoleAssignments: <TVersion extends ListAccountRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: ListAccountRoleAssignmentsArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListAccountRoleAssignmentsResponse<ExtractApiVersion<TVersion>>>) => ListAccountRoleAssignmentsResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListAccountRoleAssignmentsArg, type ListAccountRoleAssignmentsResponse, type ListAccountRoleAssignmentsResult, type ListAccountRoleAssignmentsVersion, listAccountRoleAssignments, };

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

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