@equinor/fusion-services 0.2.0

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

@@ -0,0 +1,145 @@
+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 `listRoleBindingConfigurationHistory` accepts for
+ * `GET /role-binding-configurations/{identifier}/history`.
+ *
+ * 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 ListRoleBindingConfigurationHistoryArg} and
+ * {@link ListRoleBindingConfigurationHistoryResponse}.
+ */
+type ListRoleBindingConfigurationHistoryVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listRoleBindingConfigurationHistory`, implementing
+ * `GET /role-binding-configurations/{identifier}/history`.
+ *
+ * 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;
+            top: z.ZodOptional<z.ZodNumber>;
+            skip: z.ZodOptional<z.ZodNumber>;
+        }, 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;
+                executedAt?: string | undefined;
+                bindingType?: string | undefined;
+                sourceSystem?: string | undefined;
+                triggerType?: string | undefined;
+                outcome?: string | undefined;
+                errorMessage?: string | null | undefined;
+                rolesAffected?: string[] | undefined;
+                claimableRolesAffected?: string[] | undefined;
+                assignedUserIds?: string[] | undefined;
+                removedUserIds?: string[] | undefined;
+                metadata?: string | null | undefined;
+            }, unknown, z.core.$ZodTypeInternals<{
+                id?: string | undefined;
+                executedAt?: string | undefined;
+                bindingType?: string | undefined;
+                sourceSystem?: string | undefined;
+                triggerType?: string | undefined;
+                outcome?: string | undefined;
+                errorMessage?: string | null | undefined;
+                rolesAffected?: string[] | undefined;
+                claimableRolesAffected?: string[] | undefined;
+                assignedUserIds?: string[] | undefined;
+                removedUserIds?: string[] | undefined;
+                metadata?: string | null | undefined;
+            }, unknown>>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `listRoleBindingConfigurationHistory` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiPagedCollectionV1<ApiBindingExecutionRecordV1>`, inferred from
+ * `apiPagedCollectionSchemaV1(ApiBindingExecutionRecordSchemaV1)` — the very schema that
+ * validates the `200 OK` body at runtime.
+ */
+type ListRoleBindingConfigurationHistoryResponse<TVersion extends ListRoleBindingConfigurationHistoryVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listRoleBindingConfigurationHistory` accepts, resolved from the selected API
+ * version.
+ *
+ * Version 1.0 accepts the path identifier `identifier`, and the optional query options `top`,
+ * `skip`.
+ *
+ * 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 ListRoleBindingConfigurationHistoryArg<TVersion extends ListRoleBindingConfigurationHistoryVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listRoleBindingConfigurationHistory` hands back once the request runs, for the selected
+ * API version and client method.
+ *
+ * `'json'` gives `Promise<ListRoleBindingConfigurationHistoryResponse<TVersion>>` and `'json$'`
+ * gives `StreamResponse<ListRoleBindingConfigurationHistoryResponse<TVersion>>`, so promise and
+ * observable callers share one response type.
+ */
+type ListRoleBindingConfigurationHistoryResult<TVersion extends ListRoleBindingConfigurationHistoryVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListRoleBindingConfigurationHistoryResponse<TVersion>>[TMethod];
+/**
+ * Lists the sync execution history of one role binding configuration, newest execution first.
+ *
+ * Roles V2 operation: `GET /role-binding-configurations/{identifier}/history` — "Get execution
+ * history for a role binding configuration. Returns a paginated list of sync execution records
+ * in descending order by execution time."
+ *
+ * Curried in two stages: `listRoleBindingConfigurationHistory(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 ListRoleBindingConfigurationHistoryArg} plus an optional `ClientRequestInit`, and
+ * gives back {@link ListRoleBindingConfigurationHistoryResult}.
+ *
+ * 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(ApiBindingExecutionRecordSchemaV1)`, 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).
+ *
+ * Roles V2 answers `200 OK`; the body is typed
+ * `ApiPagedCollectionV1<ApiBindingExecutionRecordV1>`.
+ *
+ * @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 ListRoleBindingConfigurationHistoryArg} and an
+ * optional `ClientRequestInit`, returning {@link ListRoleBindingConfigurationHistoryResult}.
+ * @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 { listRoleBindingConfigurationHistory } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listRoleBindingConfigurationHistory('v1', httpClient)({
+ *   identifier: 'org-chart-sync',
+ *   top: 25,
+ * });
+ * ```
+ */
+declare const listRoleBindingConfigurationHistory: <TVersion extends ListRoleBindingConfigurationHistoryVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: ListRoleBindingConfigurationHistoryArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListRoleBindingConfigurationHistoryResponse<ExtractApiVersion<TVersion>>>) => ListRoleBindingConfigurationHistoryResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListRoleBindingConfigurationHistoryArg, type ListRoleBindingConfigurationHistoryResponse, type ListRoleBindingConfigurationHistoryResult, type ListRoleBindingConfigurationHistoryVersion, listRoleBindingConfigurationHistory, };

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

@@ -0,0 +1,125 @@
+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 `createRoleBindingConfigurationHistoryRecord` accepts for
+ * `POST /role-binding-configurations/{identifier}/history`.
+ *
+ * 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 CreateRoleBindingConfigurationHistoryRecordArg} and
+ * {@link CreateRoleBindingConfigurationHistoryRecordResponse}.
+ */
+type CreateRoleBindingConfigurationHistoryRecordVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `createRoleBindingConfigurationHistoryRecord`, implementing
+ * `POST /role-binding-configurations/{identifier}/history`.
+ *
+ * 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<{
+            executedAt: z.ZodOptional<z.ZodString>;
+            triggerType: z.ZodOptional<z.ZodString>;
+            outcome: z.ZodOptional<z.ZodString>;
+            errorMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            rolesAffected: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            claimableRolesAffected: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            assignedUserIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            removedUserIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            metadata: 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>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `createRoleBindingConfigurationHistoryRecord` resolves for the selected API
+ * version.
+ *
+ * Version 1.0 resolves to `CreateBindingExecutionRecordResponseV1`, inferred from
+ * `CreateBindingExecutionRecordResponseSchemaV1` — the very schema that validates the `201
+ * Created` body at runtime.
+ */
+type CreateRoleBindingConfigurationHistoryRecordResponse<TVersion extends CreateRoleBindingConfigurationHistoryRecordVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `createRoleBindingConfigurationHistoryRecord` accepts, resolved from the selected
+ * API version.
+ *
+ * Version 1.0 accepts the path identifier `identifier`, and the request body fields of
+ * `CreateBindingExecutionRecordRequestV1`.
+ *
+ * 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 CreateRoleBindingConfigurationHistoryRecordArg<TVersion extends CreateRoleBindingConfigurationHistoryRecordVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `createRoleBindingConfigurationHistoryRecord` hands back once the request runs, for the
+ * selected API version and client method.
+ *
+ * `'json'` gives `Promise<CreateRoleBindingConfigurationHistoryRecordResponse<TVersion>>` and
+ * `'json$'` gives
+ * `StreamResponse<CreateRoleBindingConfigurationHistoryRecordResponse<TVersion>>`, so promise
+ * and observable callers share one response type.
+ */
+type CreateRoleBindingConfigurationHistoryRecordResult<TVersion extends CreateRoleBindingConfigurationHistoryRecordVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<CreateRoleBindingConfigurationHistoryRecordResponse<TVersion>>[TMethod];
+/**
+ * Records one sync execution in a role binding configuration's execution history.
+ *
+ * Roles V2 operation: `POST /role-binding-configurations/{identifier}/history` — "Create an
+ * execution history record for a role binding configuration."
+ *
+ * Curried in two stages: `createRoleBindingConfigurationHistoryRecord(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 CreateRoleBindingConfigurationHistoryRecordArg} plus an optional
+ * `ClientRequestInit`, and gives back
+ * {@link CreateRoleBindingConfigurationHistoryRecordResult}.
+ *
+ * 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
+ * `CreateBindingExecutionRecordResponseSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `201 Created`; the body is typed `CreateBindingExecutionRecordResponseV1`.
+ * 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 CreateRoleBindingConfigurationHistoryRecordArg} and
+ * an optional `ClientRequestInit`, returning
+ * {@link CreateRoleBindingConfigurationHistoryRecordResult}.
+ * @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 { createRoleBindingConfigurationHistoryRecord } from '@equinor/fusion-services/roles';
+ *
+ * const record = await createRoleBindingConfigurationHistoryRecord('v1', httpClient)({
+ *   identifier: 'org-chart-sync',
+ *   triggerType: 'Scheduled',
+ *   outcome: 'Success',
+ *   executedAt: '2026-01-15T04:00:00Z',
+ * });
+ * ```
+ */
+declare const createRoleBindingConfigurationHistoryRecord: <TVersion extends CreateRoleBindingConfigurationHistoryRecordVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: CreateRoleBindingConfigurationHistoryRecordArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, CreateRoleBindingConfigurationHistoryRecordResponse<ExtractApiVersion<TVersion>>>) => CreateRoleBindingConfigurationHistoryRecordResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type CreateRoleBindingConfigurationHistoryRecordArg, type CreateRoleBindingConfigurationHistoryRecordResponse, type CreateRoleBindingConfigurationHistoryRecordResult, type CreateRoleBindingConfigurationHistoryRecordVersion, createRoleBindingConfigurationHistoryRecord, };

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

@@ -0,0 +1,140 @@
+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 `listRoleBindingConfigurationNotifications` accepts for
+ * `GET /role-binding-configurations/{identifier}/notifications`.
+ *
+ * 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 ListRoleBindingConfigurationNotificationsArg} and
+ * {@link ListRoleBindingConfigurationNotificationsResponse}.
+ */
+type ListRoleBindingConfigurationNotificationsVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listRoleBindingConfigurationNotifications`, implementing
+ * `GET /role-binding-configurations/{identifier}/notifications`.
+ *
+ * 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;
+            top: z.ZodOptional<z.ZodNumber>;
+            skip: z.ZodOptional<z.ZodNumber>;
+        }, 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;
+                receivedAt?: string | undefined;
+                bindingType?: string | undefined;
+                sourceSystem?: string | undefined;
+                notificationType?: string | undefined;
+                processingResult?: string | undefined;
+                errorMessage?: string | null | undefined;
+                metadata?: string | null | undefined;
+            }, unknown, z.core.$ZodTypeInternals<{
+                id?: string | undefined;
+                receivedAt?: string | undefined;
+                bindingType?: string | undefined;
+                sourceSystem?: string | undefined;
+                notificationType?: string | undefined;
+                processingResult?: string | undefined;
+                errorMessage?: string | null | undefined;
+                metadata?: string | null | undefined;
+            }, unknown>>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `listRoleBindingConfigurationNotifications` resolves for the selected API
+ * version.
+ *
+ * Version 1.0 resolves to `ApiPagedCollectionV1<ApiBindingNotificationRecordV1>`, inferred from
+ * `apiPagedCollectionSchemaV1(ApiBindingNotificationRecordSchemaV1)` — the very schema that
+ * validates the `200 OK` body at runtime.
+ */
+type ListRoleBindingConfigurationNotificationsResponse<TVersion extends ListRoleBindingConfigurationNotificationsVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listRoleBindingConfigurationNotifications` accepts, resolved from the selected API
+ * version.
+ *
+ * Version 1.0 accepts the path identifier `identifier`, and the optional query options `top`,
+ * `skip`.
+ *
+ * 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 ListRoleBindingConfigurationNotificationsArg<TVersion extends ListRoleBindingConfigurationNotificationsVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listRoleBindingConfigurationNotifications` hands back once the request runs, for the
+ * selected API version and client method.
+ *
+ * `'json'` gives `Promise<ListRoleBindingConfigurationNotificationsResponse<TVersion>>` and
+ * `'json$'` gives
+ * `StreamResponse<ListRoleBindingConfigurationNotificationsResponse<TVersion>>`, so promise and
+ * observable callers share one response type.
+ */
+type ListRoleBindingConfigurationNotificationsResult<TVersion extends ListRoleBindingConfigurationNotificationsVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListRoleBindingConfigurationNotificationsResponse<TVersion>>[TMethod];
+/**
+ * Lists the notification log of one role binding configuration, newest notification first.
+ *
+ * Roles V2 operation: `GET /role-binding-configurations/{identifier}/notifications` — "Get
+ * notification log for a role binding configuration. Returns a paginated list of notification
+ * records in descending order by received time."
+ *
+ * Curried in two stages: `listRoleBindingConfigurationNotifications(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 ListRoleBindingConfigurationNotificationsArg} plus an optional
+ * `ClientRequestInit`, and gives back {@link ListRoleBindingConfigurationNotificationsResult}.
+ *
+ * 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(ApiBindingNotificationRecordSchemaV1)`, 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).
+ *
+ * Roles V2 answers `200 OK`; the body is typed
+ * `ApiPagedCollectionV1<ApiBindingNotificationRecordV1>`.
+ *
+ * @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 ListRoleBindingConfigurationNotificationsArg} and
+ * an optional `ClientRequestInit`, returning
+ * {@link ListRoleBindingConfigurationNotificationsResult}.
+ * @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 { listRoleBindingConfigurationNotifications } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listRoleBindingConfigurationNotifications('v1', httpClient)({
+ *   identifier: 'org-chart-sync',
+ *   top: 25,
+ * });
+ * ```
+ */
+declare const listRoleBindingConfigurationNotifications: <TVersion extends ListRoleBindingConfigurationNotificationsVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: ListRoleBindingConfigurationNotificationsArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListRoleBindingConfigurationNotificationsResponse<ExtractApiVersion<TVersion>>>) => ListRoleBindingConfigurationNotificationsResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListRoleBindingConfigurationNotificationsArg, type ListRoleBindingConfigurationNotificationsResponse, type ListRoleBindingConfigurationNotificationsResult, type ListRoleBindingConfigurationNotificationsVersion, listRoleBindingConfigurationNotifications, };

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

@@ -0,0 +1,122 @@
+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 `createRoleBindingConfigurationNotificationRecord` accepts for
+ * `POST /role-binding-configurations/{identifier}/notifications`.
+ *
+ * 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 CreateRoleBindingConfigurationNotificationRecordArg} and
+ * {@link CreateRoleBindingConfigurationNotificationRecordResponse}.
+ */
+type CreateRoleBindingConfigurationNotificationRecordVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `createRoleBindingConfigurationNotificationRecord`, implementing
+ * `POST /role-binding-configurations/{identifier}/notifications`.
+ *
+ * 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<{
+            receivedAt: z.ZodOptional<z.ZodString>;
+            notificationType: z.ZodOptional<z.ZodString>;
+            processingResult: z.ZodOptional<z.ZodString>;
+            errorMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            metadata: 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>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `createRoleBindingConfigurationNotificationRecord` resolves for the selected
+ * API version.
+ *
+ * Version 1.0 resolves to `CreateBindingNotificationRecordResponseV1`, inferred from
+ * `CreateBindingNotificationRecordResponseSchemaV1` — the very schema that validates the `201
+ * Created` body at runtime.
+ */
+type CreateRoleBindingConfigurationNotificationRecordResponse<TVersion extends CreateRoleBindingConfigurationNotificationRecordVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `createRoleBindingConfigurationNotificationRecord` accepts, resolved from the
+ * selected API version.
+ *
+ * Version 1.0 accepts the path identifier `identifier`, and the request body fields of
+ * `CreateBindingNotificationRecordRequestV1`.
+ *
+ * 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 CreateRoleBindingConfigurationNotificationRecordArg<TVersion extends CreateRoleBindingConfigurationNotificationRecordVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `createRoleBindingConfigurationNotificationRecord` hands back once the request runs, for
+ * the selected API version and client method.
+ *
+ * `'json'` gives `Promise<CreateRoleBindingConfigurationNotificationRecordResponse<TVersion>>`
+ * and `'json$'` gives
+ * `StreamResponse<CreateRoleBindingConfigurationNotificationRecordResponse<TVersion>>`, so
+ * promise and observable callers share one response type.
+ */
+type CreateRoleBindingConfigurationNotificationRecordResult<TVersion extends CreateRoleBindingConfigurationNotificationRecordVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<CreateRoleBindingConfigurationNotificationRecordResponse<TVersion>>[TMethod];
+/**
+ * Records one received notification in a role binding configuration's notification log.
+ *
+ * Roles V2 operation: `POST /role-binding-configurations/{identifier}/notifications` — "Create
+ * a notification log record for a role binding configuration."
+ *
+ * Curried in two stages: `createRoleBindingConfigurationNotificationRecord(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 CreateRoleBindingConfigurationNotificationRecordArg} plus an optional
+ * `ClientRequestInit`, and gives back
+ * {@link CreateRoleBindingConfigurationNotificationRecordResult}.
+ *
+ * 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
+ * `CreateBindingNotificationRecordResponseSchemaV1`, and sends `api-version=1.0` on the
+ * request.
+ *
+ * Roles V2 answers `201 Created`; the body is typed
+ * `CreateBindingNotificationRecordResponseV1`. 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 CreateRoleBindingConfigurationNotificationRecordArg} and an optional
+ * `ClientRequestInit`, returning
+ * {@link CreateRoleBindingConfigurationNotificationRecordResult}.
+ * @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 { createRoleBindingConfigurationNotificationRecord } from '@equinor/fusion-services/roles';
+ *
+ * const record = await createRoleBindingConfigurationNotificationRecord('v1', httpClient)({
+ *   identifier: 'org-chart-sync',
+ *   notificationType: 'OrgChartChanged',
+ *   processingResult: 'Processed',
+ * });
+ * ```
+ */
+declare const createRoleBindingConfigurationNotificationRecord: <TVersion extends CreateRoleBindingConfigurationNotificationRecordVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: CreateRoleBindingConfigurationNotificationRecordArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, CreateRoleBindingConfigurationNotificationRecordResponse<ExtractApiVersion<TVersion>>>) => CreateRoleBindingConfigurationNotificationRecordResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type CreateRoleBindingConfigurationNotificationRecordArg, type CreateRoleBindingConfigurationNotificationRecordResponse, type CreateRoleBindingConfigurationNotificationRecordResult, type CreateRoleBindingConfigurationNotificationRecordVersion, createRoleBindingConfigurationNotificationRecord, };

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

@@ -0,0 +1,110 @@
+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 `getRoleBindingConfigurationStatus` accepts for
+ * `GET /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 GetRoleBindingConfigurationStatusArg} and
+ * {@link GetRoleBindingConfigurationStatusResponse}.
+ */
+type GetRoleBindingConfigurationStatusVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `getRoleBindingConfigurationStatus`, implementing
+ * `GET /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<{
+            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 `getRoleBindingConfigurationStatus` 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 GetRoleBindingConfigurationStatusResponse<TVersion extends GetRoleBindingConfigurationStatusVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `getRoleBindingConfigurationStatus` 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 GetRoleBindingConfigurationStatusArg<TVersion extends GetRoleBindingConfigurationStatusVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `getRoleBindingConfigurationStatus` hands back once the request runs, for the selected
+ * API version and client method.
+ *
+ * `'json'` gives `Promise<GetRoleBindingConfigurationStatusResponse<TVersion>>` and `'json$'`
+ * gives `StreamResponse<GetRoleBindingConfigurationStatusResponse<TVersion>>`, so promise and
+ * observable callers share one response type.
+ */
+type GetRoleBindingConfigurationStatusResult<TVersion extends GetRoleBindingConfigurationStatusVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<GetRoleBindingConfigurationStatusResponse<TVersion>>[TMethod];
+/**
+ * Fetches the current synchronisation status of a role binding configuration.
+ *
+ * Roles V2 operation: `GET /role-binding-configurations/{identifier}/status` — "Get the status
+ * of a role binding configuration."
+ *
+ * Curried in two stages: `getRoleBindingConfigurationStatus(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 GetRoleBindingConfigurationStatusArg} plus an optional `ClientRequestInit`, and gives
+ * back {@link GetRoleBindingConfigurationStatusResult}.
+ *
+ * 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`.
+ *
+ * @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 GetRoleBindingConfigurationStatusArg} and an
+ * optional `ClientRequestInit`, returning {@link GetRoleBindingConfigurationStatusResult}.
+ * @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 { getRoleBindingConfigurationStatus } from '@equinor/fusion-services/roles';
+ *
+ * const status = await getRoleBindingConfigurationStatus('v1', httpClient)({
+ *   identifier: 'org-chart-sync',
+ * });
+ * ```
+ */
+declare const getRoleBindingConfigurationStatus: <TVersion extends GetRoleBindingConfigurationStatusVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: GetRoleBindingConfigurationStatusArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, GetRoleBindingConfigurationStatusResponse<ExtractApiVersion<TVersion>>>) => GetRoleBindingConfigurationStatusResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type GetRoleBindingConfigurationStatusArg, type GetRoleBindingConfigurationStatusResponse, type GetRoleBindingConfigurationStatusResult, type GetRoleBindingConfigurationStatusVersion, getRoleBindingConfigurationStatus, };