@equinor/fusion-services 0.2.0

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

@@ -0,0 +1,173 @@
+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 `createRoleBindingConfiguration` accepts for
+ * `POST /role-binding-configurations`.
+ *
+ * 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 CreateRoleBindingConfigurationArg} and {@link CreateRoleBindingConfigurationResponse}.
+ */
+type CreateRoleBindingConfigurationVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `createRoleBindingConfiguration`, implementing
+ * `POST /role-binding-configurations`.
+ *
+ * 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<{
+            version: z.ZodOptional<z.ZodString>;
+            identifier: z.ZodOptional<z.ZodString>;
+            system: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+            sourceSystem: z.ZodOptional<z.ZodString>;
+            binding: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                version: z.ZodString;
+                group: z.ZodObject<{
+                    id: z.ZodString;
+                    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strip>;
+                roles: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    scope: z.ZodOptional<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>>;
+                }, z.core.$strip>>>>;
+                claimableRoles: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    scope: z.ZodOptional<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>>;
+                }, z.core.$strip>>>>;
+            }, z.core.$strip>, z.ZodObject<{
+                version: z.ZodString;
+                context: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    projectResolver: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    allowLegacyPmtFallback: z.ZodOptional<z.ZodBoolean>;
+                    orgProjectIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                }, z.core.$strip>>>;
+                syncInterval: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                profiles: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    rules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        when: z.ZodObject<{
+                            match: z.ZodString;
+                            basePositionIds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                        }, z.core.$strip>;
+                        assign: z.ZodObject<{
+                            roles: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                                name: z.ZodString;
+                                type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                                scope: z.ZodOptional<z.ZodObject<{
+                                    scopeTypeIdentifier: z.ZodString;
+                                    valueTemplate: z.ZodString;
+                                    isGlobal: z.ZodOptional<z.ZodBoolean>;
+                                }, z.core.$strip>>;
+                            }, z.core.$strip>>>>;
+                            claimableRoles: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                                name: z.ZodString;
+                                type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                                scope: z.ZodOptional<z.ZodObject<{
+                                    scopeTypeIdentifier: z.ZodString;
+                                    valueTemplate: z.ZodString;
+                                    isGlobal: z.ZodOptional<z.ZodBoolean>;
+                                }, z.core.$strip>>;
+                            }, z.core.$strip>>>>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>;
+        /** Response published by version 1.0. The operation answers `201 Created` without a body. */
+        readonly response: z.ZodVoid;
+    };
+};
+/**
+ * Response body `createRoleBindingConfiguration` resolves for the selected API version.
+ *
+ * Version 1.0 answers `201 Created` without a body, so the type resolves to `void`.
+ */
+type CreateRoleBindingConfigurationResponse<TVersion extends CreateRoleBindingConfigurationVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `createRoleBindingConfiguration` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the request body fields of `CreateRoleBindingConfigurationRequestV1`.
+ *
+ * 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 CreateRoleBindingConfigurationArg<TVersion extends CreateRoleBindingConfigurationVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `createRoleBindingConfiguration` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<CreateRoleBindingConfigurationResponse<TVersion>>` and `'json$'`
+ * gives `StreamResponse<CreateRoleBindingConfigurationResponse<TVersion>>`, so promise and
+ * observable callers share one response type.
+ */
+type CreateRoleBindingConfigurationResult<TVersion extends CreateRoleBindingConfigurationVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<CreateRoleBindingConfigurationResponse<TVersion>>[TMethod];
+/**
+ * Creates a role binding configuration, the rule set binding roles to an Entra group or an
+ * org-chart position.
+ *
+ * Roles V2 operation: `POST /role-binding-configurations` — "Create a new role binding
+ * configuration."
+ *
+ * Curried in two stages: `createRoleBindingConfiguration(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 CreateRoleBindingConfigurationArg} plus an optional `ClientRequestInit`, and gives
+ * back {@link CreateRoleBindingConfigurationResult}.
+ *
+ * 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.
+ *
+ * Roles V2 answers `201 Created` with no body, so the resolved value is `void`. A colliding
+ * name answers `409 Conflict`. 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 CreateRoleBindingConfigurationArg} and an optional
+ * `ClientRequestInit`, returning {@link CreateRoleBindingConfigurationResult}.
+ * @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 { createRoleBindingConfiguration } from '@equinor/fusion-services/roles';
+ *
+ * await createRoleBindingConfiguration('v1', httpClient)({
+ *   identifier: 'org-chart-sync',
+ *   system: 'fusion-core',
+ *   type: 'OrgChart',
+ * });
+ * ```
+ */
+declare const createRoleBindingConfiguration: <TVersion extends CreateRoleBindingConfigurationVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input?: CreateRoleBindingConfigurationArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, CreateRoleBindingConfigurationResponse<ExtractApiVersion<TVersion>>>) => CreateRoleBindingConfigurationResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type CreateRoleBindingConfigurationArg, type CreateRoleBindingConfigurationResponse, type CreateRoleBindingConfigurationResult, type CreateRoleBindingConfigurationVersion, createRoleBindingConfiguration, };

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

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod, ClientMethodType, ExtractApiVersion, FilterAllowedApiVersions, VersionedArgs, VersionedResponse } from '../types';
+import { ApiVersion } from '../static';
+/** Concrete API versions this operation publishes. */
+type AvailableVersions = ApiVersion.v1;
+/**
+ * API version identifiers `deleteRole` accepts for `DELETE /roles/{roleIdentifier}`.
+ *
+ * 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 DeleteRoleArg} and {@link DeleteRoleResponse}.
+ */
+type DeleteRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `deleteRole`, implementing `DELETE /roles/{roleIdentifier}`.
+ *
+ * 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;
+        }, z.core.$strip>;
+        /** Response published by version 1.0. The operation answers `204 No Content`. */
+        readonly response: z.ZodVoid;
+    };
+};
+/**
+ * Response body `deleteRole` resolves for the selected API version.
+ *
+ * Version 1.0 answers `204 No Content` without a body, so the type resolves to `void`.
+ */
+type DeleteRoleResponse<TVersion extends DeleteRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `deleteRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `roleIdentifier`.
+ *
+ * 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 DeleteRoleArg<TVersion extends DeleteRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `deleteRole` hands back once the request runs, for the selected API version and client
+ * method.
+ *
+ * `'json'` gives `Promise<DeleteRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<DeleteRoleResponse<TVersion>>`, so promise and observable callers share one
+ * response type.
+ */
+type DeleteRoleResult<TVersion extends DeleteRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<DeleteRoleResponse<TVersion>>[TMethod];
+/**
+ * Deletes a role, addressed by its UUID or unique role name.
+ *
+ * Roles V2 operation: `DELETE /roles/{roleIdentifier}` — "Delete a role by identifier."
+ *
+ * Curried in two stages: `deleteRole(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 DeleteRoleArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link DeleteRoleResult}.
+ *
+ * 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 role and its assignments permanently, and the deletion cannot be
+ * undone through this API. Roles V2 answers `204 No Content` with no body, so the resolved
+ * value is `void`. The contract declares `403 Forbidden` for callers the Roles service does not
+ * authorise for this operation.
+ *
+ * Related: `listRoleAssignments` shows the user and application accounts that lose the role
+ * with it.
+ *
+ * @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 DeleteRoleArg} and an optional `ClientRequestInit`,
+ * returning {@link DeleteRoleResult}.
+ * @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 { deleteRole } from '@equinor/fusion-services/roles';
+ *
+ * await deleteRole('v1', httpClient)({ roleIdentifier: 'reader' });
+ * ```
+ */
+declare const deleteRole: <TVersion extends DeleteRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: DeleteRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, DeleteRoleResponse<ExtractApiVersion<TVersion>>>) => DeleteRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type DeleteRoleArg, type DeleteRoleResponse, type DeleteRoleResult, type DeleteRoleVersion, deleteRole, };

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

@@ -0,0 +1,144 @@
+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 `getRole` accepts for `GET /roles/{roleIdentifier}`.
+ *
+ * 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 GetRoleArg} and {@link GetRoleResponse}.
+ */
+type GetRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `getRole`, implementing `GET /roles/{roleIdentifier}`.
+ *
+ * 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;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodIntersection<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            system: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            accessRoleMappings: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                accessRole: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                    scopeType: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                        id: z.ZodOptional<z.ZodString>;
+                        name: z.ZodOptional<z.ZodString>;
+                        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>>;
+            createdBy: z.ZodOptional<z.ZodObject<{
+                azureUniqueId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                mail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                displayName: z.ZodOptional<z.ZodString>;
+                upn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                accountType: z.ZodOptional<z.ZodString>;
+                accountClassification: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+            createdDate: z.ZodOptional<z.ZodString>;
+            updatedBy: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                azureUniqueId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                mail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                displayName: z.ZodOptional<z.ZodString>;
+                upn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                accountType: z.ZodOptional<z.ZodString>;
+                accountClassification: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+            updatedDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    };
+};
+/**
+ * Response body `getRole` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiRoleV1`, inferred from `ApiRoleSchemaV1` — the very schema that
+ * validates the `200 OK` body at runtime.
+ */
+type GetRoleResponse<TVersion extends GetRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `getRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `roleIdentifier`.
+ *
+ * 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 GetRoleArg<TVersion extends GetRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `getRole` hands back once the request runs, for the selected API version and client
+ * method.
+ *
+ * `'json'` gives `Promise<GetRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<GetRoleResponse<TVersion>>`, so promise and observable callers share one
+ * response type.
+ */
+type GetRoleResult<TVersion extends GetRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<GetRoleResponse<TVersion>>[TMethod];
+/**
+ * Fetches one role by its identifier, which is either a role UUID or a unique role name.
+ *
+ * Roles V2 operation: `GET /roles/{roleIdentifier}` — "Get a role by identifier."
+ *
+ * Curried in two stages: `getRole(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 GetRoleArg}
+ * plus an optional `ClientRequestInit`, and gives back {@link GetRoleResult}.
+ *
+ * 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
+ * `ApiRoleSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiRoleV1`.
+ *
+ * Related: `assignRole` grants this role to a user or application account, and
+ * `listRoleAssignments` shows every account currently holding it.
+ *
+ * @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 GetRoleArg} and an optional `ClientRequestInit`,
+ * returning {@link GetRoleResult}.
+ * @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 { getRole } from '@equinor/fusion-services/roles';
+ *
+ * const role = await getRole('v1', httpClient)({ roleIdentifier: 'reader' });
+ * ```
+ *
+ * @example
+ * Observable form: pass `json$` to receive a `StreamResponse` instead of a promise.
+ * ```ts
+ * getRole('v1', httpClient, 'json$')({ roleIdentifier: 'reader' }).subscribe(console.log);
+ * ```
+ */
+declare const getRole: <TVersion extends GetRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: GetRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, GetRoleResponse<ExtractApiVersion<TVersion>>>) => GetRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type GetRoleArg, type GetRoleResponse, type GetRoleResult, type GetRoleVersion, getRole };

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

@@ -0,0 +1,149 @@
+import { z } from 'zod';
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod, ClientMethodType, ExtractApiVersion, FilterAllowedApiVersions, VersionedArgs, VersionedResponse } from '../types';
+import { ApiVersion } from '../static';
+/** Concrete API versions this operation publishes. */
+type AvailableVersions = ApiVersion.v1;
+/**
+ * API version identifiers `updateRole` accepts for `PATCH /roles/{roleIdentifier}`.
+ *
+ * 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 UpdateRoleArg} and {@link UpdateRoleResponse}.
+ */
+type UpdateRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `updateRole`, implementing `PATCH /roles/{roleIdentifier}`.
+ *
+ * Each concrete {@link ApiVersion} maps to the argument and response schemas that
+ * version publishes, so the version a caller passes is the single discriminator
+ * for the request shape, the request path, and the response shape.
+ */
+declare const VersionContract: {
+    readonly "1.0": {
+        /** Arguments accepted by version 1.0 of this operation. */
+        readonly args: z.ZodObject<{
+            displayName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            systemIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            roleIdentifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodIntersection<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            system: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            accessRoleMappings: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                accessRole: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                    scopeType: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                        id: z.ZodOptional<z.ZodString>;
+                        name: z.ZodOptional<z.ZodString>;
+                        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>>;
+            createdBy: z.ZodOptional<z.ZodObject<{
+                azureUniqueId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                mail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                displayName: z.ZodOptional<z.ZodString>;
+                upn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                accountType: z.ZodOptional<z.ZodString>;
+                accountClassification: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+            createdDate: z.ZodOptional<z.ZodString>;
+            updatedBy: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                azureUniqueId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                mail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                displayName: z.ZodOptional<z.ZodString>;
+                upn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                accountType: z.ZodOptional<z.ZodString>;
+                accountClassification: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+            updatedDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    };
+};
+/**
+ * Response body `updateRole` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiRoleV1`, inferred from `ApiRoleSchemaV1` — the very schema that
+ * validates the `200 OK` body at runtime.
+ */
+type UpdateRoleResponse<TVersion extends UpdateRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `updateRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `roleIdentifier`, and the request body fields of
+ * `UpdateRoleRequestV1`.
+ *
+ * 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 UpdateRoleArg<TVersion extends UpdateRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `updateRole` hands back once the request runs, for the selected API version and client
+ * method.
+ *
+ * `'json'` gives `Promise<UpdateRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<UpdateRoleResponse<TVersion>>`, so promise and observable callers share one
+ * response type.
+ */
+type UpdateRoleResult<TVersion extends UpdateRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<UpdateRoleResponse<TVersion>>[TMethod];
+/**
+ * Updates the display name, description, or owning system of a role.
+ *
+ * Roles V2 operation: `PATCH /roles/{roleIdentifier}` — "Update a role by identifier."
+ *
+ * Curried in two stages: `updateRole(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 UpdateRoleArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link UpdateRoleResult}.
+ *
+ * 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
+ * `ApiRoleSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiRoleV1`. Fields left out of the arguments
+ * are not sent, so they keep their stored values. The contract declares `403 Forbidden` for
+ * callers the Roles service does not authorise for this operation.
+ *
+ * Related: `getRole` reads the stored values first, and `listRoleAssignments` shows the
+ * accounts the change affects.
+ *
+ * @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 UpdateRoleArg} and an optional `ClientRequestInit`,
+ * returning {@link UpdateRoleResult}.
+ * @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 { updateRole } from '@equinor/fusion-services/roles';
+ *
+ * const role = await updateRole('v1', httpClient)({
+ *   roleIdentifier: 'reader',
+ *   description: 'Read-only access to Fusion core',
+ * });
+ * ```
+ */
+declare const updateRole: <TVersion extends UpdateRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: UpdateRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, UpdateRoleResponse<ExtractApiVersion<TVersion>>>) => UpdateRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type UpdateRoleArg, type UpdateRoleResponse, type UpdateRoleResult, type UpdateRoleVersion, updateRole, };