@equinor/fusion-services 0.2.0

package/dist/types/roles/endpoints/role-binding-configuration-status.patch.d.ts

@@ -0,0 +1,117 @@
+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 `updateRoleBindingConfigurationStatus` accepts for
+ * `PATCH /role-binding-configurations/{identifier}/status`.
+ *
+ * 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 UpdateRoleBindingConfigurationStatusArg} and
+ * {@link UpdateRoleBindingConfigurationStatusResponse}.
+ */
+type UpdateRoleBindingConfigurationStatusVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `updateRoleBindingConfigurationStatus`, implementing
+ * `PATCH /role-binding-configurations/{identifier}/status`.
+ *
+ * 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<{
+            status: z.ZodOptional<z.ZodString>;
+            errorMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            identifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            identifier: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodString>;
+            errorMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            createdDate: z.ZodOptional<z.ZodString>;
+            updatedDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `updateRoleBindingConfigurationStatus` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiRoleBindingConfigurationStatusV1`, inferred from
+ * `ApiRoleBindingConfigurationStatusSchemaV1` — the very schema that validates the `200 OK`
+ * body at runtime.
+ */
+type UpdateRoleBindingConfigurationStatusResponse<TVersion extends UpdateRoleBindingConfigurationStatusVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `updateRoleBindingConfigurationStatus` accepts, resolved from the selected API
+ * version.
+ *
+ * Version 1.0 accepts the path identifier `identifier`, and the request body fields of
+ * `UpdateRoleBindingConfigurationStatusRequestV1`.
+ *
+ * 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 UpdateRoleBindingConfigurationStatusArg<TVersion extends UpdateRoleBindingConfigurationStatusVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `updateRoleBindingConfigurationStatus` hands back once the request runs, for the
+ * selected API version and client method.
+ *
+ * `'json'` gives `Promise<UpdateRoleBindingConfigurationStatusResponse<TVersion>>` and
+ * `'json$'` gives `StreamResponse<UpdateRoleBindingConfigurationStatusResponse<TVersion>>`, so
+ * promise and observable callers share one response type.
+ */
+type UpdateRoleBindingConfigurationStatusResult<TVersion extends UpdateRoleBindingConfigurationStatusVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<UpdateRoleBindingConfigurationStatusResponse<TVersion>>[TMethod];
+/**
+ * Creates or updates the synchronisation status of a role binding configuration.
+ *
+ * Roles V2 operation: `PATCH /role-binding-configurations/{identifier}/status` — "Create or
+ * update the status of a role binding configuration."
+ *
+ * Curried in two stages: `updateRoleBindingConfigurationStatus(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 UpdateRoleBindingConfigurationStatusArg} plus an optional `ClientRequestInit`, and
+ * gives back {@link UpdateRoleBindingConfigurationStatusResult}.
+ *
+ * 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
+ * `ApiRoleBindingConfigurationStatusSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiRoleBindingConfigurationStatusV1`. Fields
+ * left out of the arguments are not sent, so they keep their stored values. The contract
+ * declares `403 Forbidden` for callers the Roles service does not authorise for this operation.
+ *
+ * @template TVersion - Roles API version identifier: `'v1'`, `'1.0'`, or `ApiVersion.v1`.
+ * @template TMethod - Execution method: `'json'` for a promise, `'json$'` for an observable.
+ * @param version - API version selecting the request path, the argument schema, and the
+ * response schema.
+ * @param client - HTTP client that executes the request against the Roles service.
+ * @param method - Execution method, defaulting to `'json'`.
+ * @returns A request function taking {@link UpdateRoleBindingConfigurationStatusArg} and an
+ * optional `ClientRequestInit`, returning {@link UpdateRoleBindingConfigurationStatusResult}.
+ * @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 { updateRoleBindingConfigurationStatus } from '@equinor/fusion-services/roles';
+ *
+ * const status = await updateRoleBindingConfigurationStatus('v1', httpClient)({
+ *   identifier: 'org-chart-sync',
+ *   status: 'Active',
+ * });
+ * ```
+ */
+declare const updateRoleBindingConfigurationStatus: <TVersion extends UpdateRoleBindingConfigurationStatusVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: UpdateRoleBindingConfigurationStatusArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, UpdateRoleBindingConfigurationStatusResponse<ExtractApiVersion<TVersion>>>) => UpdateRoleBindingConfigurationStatusResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type UpdateRoleBindingConfigurationStatusArg, type UpdateRoleBindingConfigurationStatusResponse, type UpdateRoleBindingConfigurationStatusResult, type UpdateRoleBindingConfigurationStatusVersion, updateRoleBindingConfigurationStatus, };

package/dist/types/roles/endpoints/role-binding-configuration.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 `deleteRoleBindingConfiguration` accepts for
+ * `DELETE /role-binding-configurations/{identifier}`.
+ *
+ * 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 DeleteRoleBindingConfigurationArg} and {@link DeleteRoleBindingConfigurationResponse}.
+ */
+type DeleteRoleBindingConfigurationVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `deleteRoleBindingConfiguration`, implementing
+ * `DELETE /role-binding-configurations/{identifier}`.
+ *
+ * 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<{
+            identifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0. The operation answers `204 No Content`. */
+        readonly response: z.ZodVoid;
+    };
+};
+/**
+ * Response body `deleteRoleBindingConfiguration` resolves for the selected API version.
+ *
+ * Version 1.0 answers `204 No Content` without a body, so the type resolves to `void`.
+ */
+type DeleteRoleBindingConfigurationResponse<TVersion extends DeleteRoleBindingConfigurationVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `deleteRoleBindingConfiguration` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `identifier`.
+ *
+ * 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 DeleteRoleBindingConfigurationArg<TVersion extends DeleteRoleBindingConfigurationVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `deleteRoleBindingConfiguration` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<DeleteRoleBindingConfigurationResponse<TVersion>>` and `'json$'`
+ * gives `StreamResponse<DeleteRoleBindingConfigurationResponse<TVersion>>`, so promise and
+ * observable callers share one response type.
+ */
+type DeleteRoleBindingConfigurationResult<TVersion extends DeleteRoleBindingConfigurationVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<DeleteRoleBindingConfigurationResponse<TVersion>>[TMethod];
+/**
+ * Deletes a role binding configuration by its identifier.
+ *
+ * Roles V2 operation: `DELETE /role-binding-configurations/{identifier}` — "Delete a role
+ * binding configuration by identifier."
+ *
+ * Curried in two stages: `deleteRoleBindingConfiguration(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 DeleteRoleBindingConfigurationArg} plus an optional `ClientRequestInit`, and gives
+ * back {@link DeleteRoleBindingConfigurationResult}.
+ *
+ * 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 binding configuration 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 DeleteRoleBindingConfigurationArg} and an optional
+ * `ClientRequestInit`, returning {@link DeleteRoleBindingConfigurationResult}.
+ * @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 { deleteRoleBindingConfiguration } from '@equinor/fusion-services/roles';
+ *
+ * await deleteRoleBindingConfiguration('v1', httpClient)({ identifier: 'org-chart-sync' });
+ * ```
+ */
+declare const deleteRoleBindingConfiguration: <TVersion extends DeleteRoleBindingConfigurationVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: DeleteRoleBindingConfigurationArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, DeleteRoleBindingConfigurationResponse<ExtractApiVersion<TVersion>>>) => DeleteRoleBindingConfigurationResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type DeleteRoleBindingConfigurationArg, type DeleteRoleBindingConfigurationResponse, type DeleteRoleBindingConfigurationResult, type DeleteRoleBindingConfigurationVersion, deleteRoleBindingConfiguration, };

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

@@ -0,0 +1,117 @@
+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 `getRoleBindingConfiguration` accepts for
+ * `GET /role-binding-configurations/{identifier}`.
+ *
+ * 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 GetRoleBindingConfigurationArg} and {@link GetRoleBindingConfigurationResponse}.
+ */
+type GetRoleBindingConfigurationVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `getRoleBindingConfiguration`, implementing
+ * `GET /role-binding-configurations/{identifier}`.
+ *
+ * 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<{
+            identifier: z.ZodString;
+            includeDeleted: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+            identifier: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            system: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+            sourceSystem: z.ZodOptional<z.ZodString>;
+            isDeleted: z.ZodOptional<z.ZodBoolean>;
+            binding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `getRoleBindingConfiguration` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiRoleBindingConfigurationV1`, inferred from
+ * `ApiRoleBindingConfigurationSchemaV1` — the very schema that validates the `200 OK` body at
+ * runtime.
+ */
+type GetRoleBindingConfigurationResponse<TVersion extends GetRoleBindingConfigurationVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `getRoleBindingConfiguration` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `identifier`, and the optional query options
+ * `includeDeleted`.
+ *
+ * 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 GetRoleBindingConfigurationArg<TVersion extends GetRoleBindingConfigurationVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `getRoleBindingConfiguration` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<GetRoleBindingConfigurationResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<GetRoleBindingConfigurationResponse<TVersion>>`, so promise and observable
+ * callers share one response type.
+ */
+type GetRoleBindingConfigurationResult<TVersion extends GetRoleBindingConfigurationVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<GetRoleBindingConfigurationResponse<TVersion>>[TMethod];
+/**
+ * Fetches one role binding configuration by identifier, optionally including soft-deleted ones.
+ *
+ * Roles V2 operation: `GET /role-binding-configurations/{identifier}` — "Get a role binding
+ * configuration by identifier."
+ *
+ * Curried in two stages: `getRoleBindingConfiguration(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 GetRoleBindingConfigurationArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link GetRoleBindingConfigurationResult}.
+ *
+ * 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
+ * `ApiRoleBindingConfigurationSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Query options: `includeDeleted` also returns soft-deleted records.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiRoleBindingConfigurationV1`.
+ *
+ * @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 GetRoleBindingConfigurationArg} and an optional
+ * `ClientRequestInit`, returning {@link GetRoleBindingConfigurationResult}.
+ * @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 { getRoleBindingConfiguration } from '@equinor/fusion-services/roles';
+ *
+ * const configuration = await getRoleBindingConfiguration('v1', httpClient)({
+ *   identifier: 'org-chart-sync',
+ *   includeDeleted: true,
+ * });
+ * ```
+ */
+declare const getRoleBindingConfiguration: <TVersion extends GetRoleBindingConfigurationVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: GetRoleBindingConfigurationArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, GetRoleBindingConfigurationResponse<ExtractApiVersion<TVersion>>>) => GetRoleBindingConfigurationResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type GetRoleBindingConfigurationArg, type GetRoleBindingConfigurationResponse, type GetRoleBindingConfigurationResult, type GetRoleBindingConfigurationVersion, getRoleBindingConfiguration, };

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

@@ -0,0 +1,171 @@
+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 `updateRoleBindingConfiguration` accepts for
+ * `PATCH /role-binding-configurations/{identifier}`.
+ *
+ * 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 UpdateRoleBindingConfigurationArg} and {@link UpdateRoleBindingConfigurationResponse}.
+ */
+type UpdateRoleBindingConfigurationVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `updateRoleBindingConfiguration`, implementing
+ * `PATCH /role-binding-configurations/{identifier}`.
+ *
+ * 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<{
+            system: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            sourceSystem: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            binding: z.ZodOptional<z.ZodNullable<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>]>>>;
+            identifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0. The operation answers `204 No Content`. */
+        readonly response: z.ZodVoid;
+    };
+};
+/**
+ * Response body `updateRoleBindingConfiguration` resolves for the selected API version.
+ *
+ * Version 1.0 answers `204 No Content` without a body, so the type resolves to `void`.
+ */
+type UpdateRoleBindingConfigurationResponse<TVersion extends UpdateRoleBindingConfigurationVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `updateRoleBindingConfiguration` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `identifier`, and the request body fields of
+ * `UpdateRoleBindingConfigurationRequestV1`.
+ *
+ * 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 UpdateRoleBindingConfigurationArg<TVersion extends UpdateRoleBindingConfigurationVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `updateRoleBindingConfiguration` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<UpdateRoleBindingConfigurationResponse<TVersion>>` and `'json$'`
+ * gives `StreamResponse<UpdateRoleBindingConfigurationResponse<TVersion>>`, so promise and
+ * observable callers share one response type.
+ */
+type UpdateRoleBindingConfigurationResult<TVersion extends UpdateRoleBindingConfigurationVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<UpdateRoleBindingConfigurationResponse<TVersion>>[TMethod];
+/**
+ * Updates the binding rules and metadata of a role binding configuration.
+ *
+ * Roles V2 operation: `PATCH /role-binding-configurations/{identifier}` — "Update a role
+ * binding configuration by identifier."
+ *
+ * Curried in two stages: `updateRoleBindingConfiguration(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 UpdateRoleBindingConfigurationArg} plus an optional `ClientRequestInit`, and gives
+ * back {@link UpdateRoleBindingConfigurationResult}.
+ *
+ * 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 `204 No Content` with no body, so the resolved value is `void`. Fields left
+ * out of the arguments are not sent, so they keep their stored values. The contract declares
+ * `403 Forbidden` for callers the Roles service does not authorise for this operation.
+ *
+ * @template TVersion - Roles API version identifier: `'v1'`, `'1.0'`, or `ApiVersion.v1`.
+ * @template TMethod - Execution method: `'json'` for a promise, `'json$'` for an observable.
+ * @param version - API version selecting the request path, the argument schema, and the
+ * response schema.
+ * @param client - HTTP client that executes the request against the Roles service.
+ * @param method - Execution method, defaulting to `'json'`.
+ * @returns A request function taking {@link UpdateRoleBindingConfigurationArg} and an optional
+ * `ClientRequestInit`, returning {@link UpdateRoleBindingConfigurationResult}.
+ * @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 { updateRoleBindingConfiguration } from '@equinor/fusion-services/roles';
+ *
+ * await updateRoleBindingConfiguration('v1', httpClient)({
+ *   identifier: 'org-chart-sync',
+ *   description: 'Sync approvers from the org chart',
+ * });
+ * ```
+ */
+declare const updateRoleBindingConfiguration: <TVersion extends UpdateRoleBindingConfigurationVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: UpdateRoleBindingConfigurationArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, UpdateRoleBindingConfigurationResponse<ExtractApiVersion<TVersion>>>) => UpdateRoleBindingConfigurationResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type UpdateRoleBindingConfigurationArg, type UpdateRoleBindingConfigurationResponse, type UpdateRoleBindingConfigurationResult, type UpdateRoleBindingConfigurationVersion, updateRoleBindingConfiguration, };

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

@@ -0,0 +1,115 @@
+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 `listRoleBindingConfigurations` accepts for
+ * `GET /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 ListRoleBindingConfigurationsArg} and {@link ListRoleBindingConfigurationsResponse}.
+ */
+type ListRoleBindingConfigurationsVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listRoleBindingConfigurations`, implementing
+ * `GET /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<{
+            top: z.ZodOptional<z.ZodNumber>;
+            skip: z.ZodOptional<z.ZodNumber>;
+            includeDeleted: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+            identifier: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+            system: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+            sourceSystem: z.ZodOptional<z.ZodString>;
+            isDeleted: z.ZodOptional<z.ZodBoolean>;
+            binding: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+    };
+};
+/**
+ * Response body `listRoleBindingConfigurations` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiRoleBindingConfigurationV1[]`, inferred from
+ * `z.array(ApiRoleBindingConfigurationSchemaV1)` — the very schema that validates the `200 OK`
+ * body at runtime.
+ */
+type ListRoleBindingConfigurationsResponse<TVersion extends ListRoleBindingConfigurationsVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listRoleBindingConfigurations` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the optional query options `top`, `skip`, `includeDeleted`.
+ *
+ * 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 ListRoleBindingConfigurationsArg<TVersion extends ListRoleBindingConfigurationsVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listRoleBindingConfigurations` hands back once the request runs, for the selected API
+ * version and client method.
+ *
+ * `'json'` gives `Promise<ListRoleBindingConfigurationsResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<ListRoleBindingConfigurationsResponse<TVersion>>`, so promise and observable
+ * callers share one response type.
+ */
+type ListRoleBindingConfigurationsResult<TVersion extends ListRoleBindingConfigurationsVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListRoleBindingConfigurationsResponse<TVersion>>[TMethod];
+/**
+ * Lists every role binding configuration, optionally including soft-deleted ones.
+ *
+ * Roles V2 operation: `GET /role-binding-configurations` — "Get all role binding
+ * configurations."
+ *
+ * Curried in two stages: `listRoleBindingConfigurations(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 ListRoleBindingConfigurationsArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link ListRoleBindingConfigurationsResult}.
+ *
+ * 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(ApiRoleBindingConfigurationSchemaV1)`, 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 `includeDeleted` also returns soft-deleted records.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiRoleBindingConfigurationV1[]`.
+ *
+ * @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 ListRoleBindingConfigurationsArg} and an optional
+ * `ClientRequestInit`, returning {@link ListRoleBindingConfigurationsResult}.
+ * @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 { listRoleBindingConfigurations } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listRoleBindingConfigurations('v1', httpClient)({ top: 25 });
+ * ```
+ */
+declare const listRoleBindingConfigurations: <TVersion extends ListRoleBindingConfigurationsVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input?: ListRoleBindingConfigurationsArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListRoleBindingConfigurationsResponse<ExtractApiVersion<TVersion>>>) => ListRoleBindingConfigurationsResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListRoleBindingConfigurationsArg, type ListRoleBindingConfigurationsResponse, type ListRoleBindingConfigurationsResult, type ListRoleBindingConfigurationsVersion, listRoleBindingConfigurations, };