@equinor/fusion-services 0.2.0

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

@@ -0,0 +1,108 @@
+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 `deleteRoleAssignments` accepts for
+ * `POST /roles/{roleIdentifier}/assignments/delete`.
+ *
+ * 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 DeleteRoleAssignmentsArg} and {@link DeleteRoleAssignmentsResponse}.
+ */
+type DeleteRoleAssignmentsVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `deleteRoleAssignments`, implementing
+ * `POST /roles/{roleIdentifier}/assignments/delete`.
+ *
+ * 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<{
+            roleAssignmentIds: z.ZodArray<z.ZodString>;
+            roleIdentifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0. The operation answers `204 No Content`. */
+        readonly response: z.ZodVoid;
+    };
+};
+/**
+ * Response body `deleteRoleAssignments` resolves for the selected API version.
+ *
+ * Version 1.0 answers `204 No Content` without a body, so the type resolves to `void`.
+ */
+type DeleteRoleAssignmentsResponse<TVersion extends DeleteRoleAssignmentsVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `deleteRoleAssignments` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `roleIdentifier`, and the request body fields of
+ * `DeleteRoleAssignmentsRequestV1`.
+ *
+ * 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 DeleteRoleAssignmentsArg<TVersion extends DeleteRoleAssignmentsVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `deleteRoleAssignments` hands back once the request runs, for the selected API version
+ * and client method.
+ *
+ * `'json'` gives `Promise<DeleteRoleAssignmentsResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<DeleteRoleAssignmentsResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type DeleteRoleAssignmentsResult<TVersion extends DeleteRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<DeleteRoleAssignmentsResponse<TVersion>>[TMethod];
+/**
+ * Deletes up to 100 assignments of one role in a single batch request, addressed by their
+ * assignment IDs.
+ *
+ * Roles V2 operation: `POST /roles/{roleIdentifier}/assignments/delete` — "Batch delete role
+ * assignments by their IDs. A maximum of 100 role assignments can be deleted in a single
+ * request."
+ *
+ * Curried in two stages: `deleteRoleAssignments(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 DeleteRoleAssignmentsArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link DeleteRoleAssignmentsResult}.
+ *
+ * The version argument is the single discriminator: `'v1'` — equivalently `'1.0'` or
+ * `ApiVersion.v1` — selects the version-1.0 argument schema, expects the empty success body,
+ * and sends `api-version=1.0` on the request.
+ *
+ * Destructive: it removes every role assignment named in the batch 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 DeleteRoleAssignmentsArg} and an optional
+ * `ClientRequestInit`, returning {@link DeleteRoleAssignmentsResult}.
+ * @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 { deleteRoleAssignments } from '@equinor/fusion-services/roles';
+ *
+ * await deleteRoleAssignments('v1', httpClient)({
+ *   roleIdentifier: 'reader',
+ *   roleAssignmentIds: ['0f5a8d1c-2b3e-4a6f-9c10-7d8e9f0a1b2c'],
+ * });
+ * ```
+ */
+declare const deleteRoleAssignments: <TVersion extends DeleteRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: DeleteRoleAssignmentsArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, DeleteRoleAssignmentsResponse<ExtractApiVersion<TVersion>>>) => DeleteRoleAssignmentsResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type DeleteRoleAssignmentsArg, type DeleteRoleAssignmentsResponse, type DeleteRoleAssignmentsResult, type DeleteRoleAssignmentsVersion, deleteRoleAssignments, };

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

@@ -0,0 +1,184 @@
+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 `listRoleAssignments` accepts for
+ * `GET /roles/{roleIdentifier}/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 ListRoleAssignmentsArg} and {@link ListRoleAssignmentsResponse}.
+ */
+type ListRoleAssignmentsVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listRoleAssignments`, implementing
+ * `GET /roles/{roleIdentifier}/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<{
+            roleIdentifier: z.ZodString;
+            top: z.ZodOptional<z.ZodNumber>;
+            skip: z.ZodOptional<z.ZodNumber>;
+            filter: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodObject<{
+            totalCount: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            count: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            nextPage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            prevPage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            value: z.ZodOptional<z.ZodArray<z.ZodType<{
+                id?: string | undefined;
+                assignedTo?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | undefined;
+                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;
+            }, 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;
+            }, unknown>>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `listRoleAssignments` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiPagedCollectionV1<ApiRoleAssignmentV1>`, inferred from
+ * `apiPagedCollectionSchemaV1(ApiRoleAssignmentSchemaV1)` — the very schema that validates the
+ * `200 OK` body at runtime.
+ */
+type ListRoleAssignmentsResponse<TVersion extends ListRoleAssignmentsVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listRoleAssignments` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `roleIdentifier`, and the optional query options
+ * `top`, `skip`, `filter`.
+ *
+ * The value is parsed by the version's Zod argument schema before the request path is built, so
+ * defaults and range checks apply up front.
+ */
+type ListRoleAssignmentsArg<TVersion extends ListRoleAssignmentsVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listRoleAssignments` hands back once the request runs, for the selected API version and
+ * client method.
+ *
+ * `'json'` gives `Promise<ListRoleAssignmentsResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<ListRoleAssignmentsResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type ListRoleAssignmentsResult<TVersion extends ListRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListRoleAssignmentsResponse<TVersion>>[TMethod];
+/**
+ * Lists the assignments of one role: which user and application accounts hold it, with the
+ * scope and validity of each assignment.
+ *
+ * Roles V2 operation: `GET /roles/{roleIdentifier}/assignments` — "Get role assignments for a
+ * role."
+ *
+ * Curried in two stages: `listRoleAssignments(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 ListRoleAssignmentsArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link ListRoleAssignmentsResult}.
+ *
+ * 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(ApiRoleAssignmentSchemaV1)`, and sends `api-version=1.0` on the
+ * request.
+ *
+ * Query options: `top` and `skip` page the collection as `$top` and `$skip` (`top` accepts
+ * 0–100); and `filter` is sent as an OData `$filter` expression.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiPagedCollectionV1<ApiRoleAssignmentV1>`.
+ *
+ * Related: `assignRole` creates an assignment, `getRoleAssignment` reads a single one, and
+ * `getRole` fetches the role itself.
+ *
+ * @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 ListRoleAssignmentsArg} and an optional
+ * `ClientRequestInit`, returning {@link ListRoleAssignmentsResult}.
+ * @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 { listRoleAssignments } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listRoleAssignments('v1', httpClient)({
+ *   roleIdentifier: 'reader',
+ *   top: 25,
+ * });
+ * ```
+ */
+declare const listRoleAssignments: <TVersion extends ListRoleAssignmentsVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: ListRoleAssignmentsArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListRoleAssignmentsResponse<ExtractApiVersion<TVersion>>>) => ListRoleAssignmentsResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListRoleAssignmentsArg, type ListRoleAssignmentsResponse, type ListRoleAssignmentsResult, type ListRoleAssignmentsVersion, listRoleAssignments, };

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

@@ -0,0 +1,151 @@
+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 `assignRole` accepts for `POST /roles/{roleIdentifier}/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 AssignRoleArg} and {@link AssignRoleResponse}.
+ */
+type AssignRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `assignRole`, implementing `POST /roles/{roleIdentifier}/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>>>;
+            roleIdentifier: 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>>;
+            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>>;
+            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>>;
+            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 `assignRole` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiRoleAssignmentV1`, inferred from `ApiRoleAssignmentSchemaV1` —
+ * the very schema that validates the `201 Created` body at runtime.
+ */
+type AssignRoleResponse<TVersion extends AssignRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `assignRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `roleIdentifier`, and the request body fields of
+ * `AssignRoleRequestV1`.
+ *
+ * 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 AssignRoleArg<TVersion extends AssignRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `assignRole` hands back once the request runs, for the selected API version and client
+ * method.
+ *
+ * `'json'` gives `Promise<AssignRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<AssignRoleResponse<TVersion>>`, so promise and observable callers share one
+ * response type.
+ */
+type AssignRoleResult<TVersion extends AssignRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<AssignRoleResponse<TVersion>>[TMethod];
+/**
+ * Assigns a role to a user or application, optionally scoped, tagged, and time-boxed by the
+ * request body.
+ *
+ * Roles V2 operation: `POST /roles/{roleIdentifier}/assignments` — "Assign a role assignment"
+ *
+ * Curried in two stages: `assignRole(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 AssignRoleArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link AssignRoleResult}.
+ *
+ * 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
+ * `ApiRoleAssignmentSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `201 Created`; the body is typed `ApiRoleAssignmentV1`. The contract
+ * declares `403 Forbidden` for callers the Roles service does not authorise for this operation.
+ *
+ * Related: `listAccountRoleAssignments` shows everything one user or application account
+ * already holds.
+ *
+ * @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 AssignRoleArg} and an optional `ClientRequestInit`,
+ * returning {@link AssignRoleResult}.
+ * @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 { assignRole } from '@equinor/fusion-services/roles';
+ *
+ * const assignment = await assignRole('v1', httpClient)({
+ *   roleIdentifier: 'reader',
+ *   accountIdentifier: 'user@equinor.com',
+ *   validTo: '2026-12-31T23:59:59Z',
+ * });
+ * ```
+ */
+declare const assignRole: <TVersion extends AssignRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: AssignRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, AssignRoleResponse<ExtractApiVersion<TVersion>>>) => AssignRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type AssignRoleArg, type AssignRoleResponse, type AssignRoleResult, type AssignRoleVersion, assignRole, };

package/dist/types/roles/endpoints/role-binding-configuration-expired-history.delete.d.ts

@@ -0,0 +1,109 @@
+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 `purgeExpiredRoleBindingConfigurationHistory` accepts for
+ * `DELETE /role-binding-configurations/history/expired`.
+ *
+ * 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 PurgeExpiredRoleBindingConfigurationHistoryArg} and
+ * {@link PurgeExpiredRoleBindingConfigurationHistoryResponse}.
+ */
+type PurgeExpiredRoleBindingConfigurationHistoryVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `purgeExpiredRoleBindingConfigurationHistory`, implementing
+ * `DELETE /role-binding-configurations/history/expired`.
+ *
+ * Each concrete {@link ApiVersion} maps to the argument and response schemas that
+ * version publishes, so the version a caller passes is the single discriminator
+ * for the request shape, the request path, and the response shape.
+ */
+declare const VersionContract: {
+    readonly "1.0": {
+        /** Arguments accepted by version 1.0 of this operation. */
+        readonly args: z.ZodObject<{}, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodObject<{
+            deletedCount: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `purgeExpiredRoleBindingConfigurationHistory` resolves for the selected API
+ * version.
+ *
+ * Version 1.0 resolves to `ApiPurgeBindingResultV1`, inferred from
+ * `ApiPurgeBindingResultSchemaV1` — the very schema that validates the `200 OK` body at
+ * runtime.
+ */
+type PurgeExpiredRoleBindingConfigurationHistoryResponse<TVersion extends PurgeExpiredRoleBindingConfigurationHistoryVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `purgeExpiredRoleBindingConfigurationHistory` accepts, resolved from the selected
+ * API version.
+ *
+ * Version 1.0 of this operation takes no arguments, so the shape is an empty object.
+ *
+ * The value is parsed by the version's Zod argument schema before the request path is built, so
+ * defaults and range checks apply up front.
+ */
+type PurgeExpiredRoleBindingConfigurationHistoryArg<TVersion extends PurgeExpiredRoleBindingConfigurationHistoryVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `purgeExpiredRoleBindingConfigurationHistory` hands back once the request runs, for the
+ * selected API version and client method.
+ *
+ * `'json'` gives `Promise<PurgeExpiredRoleBindingConfigurationHistoryResponse<TVersion>>` and
+ * `'json$'` gives
+ * `StreamResponse<PurgeExpiredRoleBindingConfigurationHistoryResponse<TVersion>>`, so promise
+ * and observable callers share one response type.
+ */
+type PurgeExpiredRoleBindingConfigurationHistoryResult<TVersion extends PurgeExpiredRoleBindingConfigurationHistoryVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<PurgeExpiredRoleBindingConfigurationHistoryResponse<TVersion>>[TMethod];
+/**
+ * Purges role binding execution history and notification records that have aged out of the
+ * retention window.
+ *
+ * Roles V2 operation: `DELETE /role-binding-configurations/history/expired` — "Purge expired
+ * history and notification records beyond the retention window."
+ *
+ * Curried in two stages: `purgeExpiredRoleBindingConfigurationHistory(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 PurgeExpiredRoleBindingConfigurationHistoryArg} plus an optional
+ * `ClientRequestInit`, and gives back
+ * {@link PurgeExpiredRoleBindingConfigurationHistoryResult}.
+ *
+ * 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
+ * `ApiPurgeBindingResultSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Destructive: it removes the expired history and notification records permanently, and the
+ * deletion cannot be undone through this API. Roles V2 answers `200 OK`; the body is typed
+ * `ApiPurgeBindingResultV1`. 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 PurgeExpiredRoleBindingConfigurationHistoryArg} and
+ * an optional `ClientRequestInit`, returning
+ * {@link PurgeExpiredRoleBindingConfigurationHistoryResult}.
+ * @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 { purgeExpiredRoleBindingConfigurationHistory } from '@equinor/fusion-services/roles';
+ *
+ * const result = await purgeExpiredRoleBindingConfigurationHistory('v1', httpClient)({});
+ * ```
+ */
+declare const purgeExpiredRoleBindingConfigurationHistory: <TVersion extends PurgeExpiredRoleBindingConfigurationHistoryVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input?: PurgeExpiredRoleBindingConfigurationHistoryArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, PurgeExpiredRoleBindingConfigurationHistoryResponse<ExtractApiVersion<TVersion>>>) => PurgeExpiredRoleBindingConfigurationHistoryResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type PurgeExpiredRoleBindingConfigurationHistoryArg, type PurgeExpiredRoleBindingConfigurationHistoryResponse, type PurgeExpiredRoleBindingConfigurationHistoryResult, type PurgeExpiredRoleBindingConfigurationHistoryVersion, purgeExpiredRoleBindingConfigurationHistory, };