@equinor/fusion-services 0.2.0

package/dist/types/roles/v1/schemas/subscription-request-schema-v1.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+/** Zod schema for the body of a Roles V2 subscription request. */
+export declare const SubscriptionRequestSchemaV1: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    identifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        Persistent: "Persistent";
+        Transient: "Transient";
+    }>>;
+    typeFilter: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+/**
+ * Request body creating or renewing a Roles API 1.0 event subscription, optionally filtered to
+ * specific event types.
+ *
+ * Roles API 1.0 model inferred from {@link SubscriptionRequestSchemaV1}, so
+ * `SubscriptionRequestV1` and the runtime validator can never describe different shapes.
+ */
+export type SubscriptionRequestV1 = z.infer<typeof SubscriptionRequestSchemaV1>;

package/dist/types/roles/v1/schemas/top-schema-v1.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+/** Zod schema fragment validating the `$top` pagination option (0 through 100 inclusive). */
+export declare const TopSchemaV1: z.ZodOptional<z.ZodNumber>;
+/**
+ * The `$top` pagination option Roles API 1.0 accepts on collection endpoints: 0 through 100
+ * records.
+ *
+ * Roles API 1.0 model inferred from {@link TopSchemaV1}, so `TopV1` and the runtime validator
+ * can never describe different shapes.
+ */
+export type TopV1 = z.infer<typeof TopSchemaV1>;

package/dist/types/roles/v1/schemas/update-access-role-assignment-request-schema-v1.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+/** Zod schema for the body of an update-access-role-assignment request. */
+export declare const UpdateAccessRoleAssignmentRequestSchemaV1: z.ZodObject<{
+    validTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Patch request body for updating an access role assignment.
+ *
+ * Roles API 1.0 model inferred from {@link UpdateAccessRoleAssignmentRequestSchemaV1}, so
+ * `UpdateAccessRoleAssignmentRequestV1` and the runtime validator can never describe different
+ * shapes.
+ */
+export type UpdateAccessRoleAssignmentRequestV1 = z.infer<typeof UpdateAccessRoleAssignmentRequestSchemaV1>;

package/dist/types/roles/v1/schemas/update-access-role-request-schema-v1.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+/** Zod schema for the body of an update-access-role request. */
+export declare const UpdateAccessRoleRequestSchemaV1: z.ZodObject<{
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Patch request body for updating an access role.
+ *
+ * Roles API 1.0 model inferred from {@link UpdateAccessRoleRequestSchemaV1}, so
+ * `UpdateAccessRoleRequestV1` and the runtime validator can never describe different shapes.
+ */
+export type UpdateAccessRoleRequestV1 = z.infer<typeof UpdateAccessRoleRequestSchemaV1>;

package/dist/types/roles/v1/schemas/update-claimable-role-assignment-request-schema-v1.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+/** Zod schema for the body of an update-claimable-role-assignment request. */
+export declare const UpdateClaimableRoleAssignmentRequestSchemaV1: z.ZodObject<{
+    validTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Patch request body for updating a claimable role assignment.
+ *
+ * Roles API 1.0 model inferred from {@link UpdateClaimableRoleAssignmentRequestSchemaV1}, so
+ * `UpdateClaimableRoleAssignmentRequestV1` and the runtime validator can never describe
+ * different shapes.
+ */
+export type UpdateClaimableRoleAssignmentRequestV1 = z.infer<typeof UpdateClaimableRoleAssignmentRequestSchemaV1>;

package/dist/types/roles/v1/schemas/update-claimable-role-request-schema-v1.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+/** Zod schema for the body of an update-claimable-role request. */
+export declare const UpdateClaimableRoleRequestSchemaV1: z.ZodObject<{
+    displayName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    systemIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Patch request body for updating a claimable role.
+ *
+ * Roles API 1.0 model inferred from {@link UpdateClaimableRoleRequestSchemaV1}, so
+ * `UpdateClaimableRoleRequestV1` and the runtime validator can never describe different shapes.
+ */
+export type UpdateClaimableRoleRequestV1 = z.infer<typeof UpdateClaimableRoleRequestSchemaV1>;

package/dist/types/roles/v1/schemas/update-role-assignment-request-schema-v1.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+/** Zod schema for the body of an update-role-assignment request. */
+export declare const UpdateRoleAssignmentRequestSchemaV1: z.ZodObject<{
+    validTo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Patch request body for updating a role assignment.
+ *
+ * Roles API 1.0 model inferred from {@link UpdateRoleAssignmentRequestSchemaV1}, so
+ * `UpdateRoleAssignmentRequestV1` and the runtime validator can never describe different
+ * shapes.
+ */
+export type UpdateRoleAssignmentRequestV1 = z.infer<typeof UpdateRoleAssignmentRequestSchemaV1>;

package/dist/types/roles/v1/schemas/update-role-binding-configuration-request-schema-v1.d.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+/** Zod schema for the body of an update-role-binding-configuration request. */
+export declare const UpdateRoleBindingConfigurationRequestSchemaV1: 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>]>>>;
+}, z.core.$strip>;
+/**
+ * Patch request body for updating a role binding configuration.
+ *
+ * Roles API 1.0 model inferred from {@link UpdateRoleBindingConfigurationRequestSchemaV1}, so
+ * `UpdateRoleBindingConfigurationRequestV1` and the runtime validator can never describe
+ * different shapes.
+ */
+export type UpdateRoleBindingConfigurationRequestV1 = z.infer<typeof UpdateRoleBindingConfigurationRequestSchemaV1>;

package/dist/types/roles/v1/schemas/update-role-binding-configuration-status-request-schema-v1.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+/** Zod schema for the body of an update-role-binding-configuration-status request. */
+export declare const UpdateRoleBindingConfigurationStatusRequestSchemaV1: z.ZodObject<{
+    status: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Request body for updating the status of a role binding configuration.
+ *
+ * Roles API 1.0 model inferred from
+ * {@link UpdateRoleBindingConfigurationStatusRequestSchemaV1}, so
+ * `UpdateRoleBindingConfigurationStatusRequestV1` and the runtime validator can never describe
+ * different shapes.
+ */
+export type UpdateRoleBindingConfigurationStatusRequestV1 = z.infer<typeof UpdateRoleBindingConfigurationStatusRequestSchemaV1>;

package/dist/types/roles/v1/schemas/update-role-request-schema-v1.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+/** Zod schema for the body of an update-role request. */
+export declare const UpdateRoleRequestSchemaV1: z.ZodObject<{
+    displayName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    systemIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Patch request body for updating a role.
+ *
+ * Roles API 1.0 model inferred from {@link UpdateRoleRequestSchemaV1}, so `UpdateRoleRequestV1`
+ * and the runtime validator can never describe different shapes.
+ */
+export type UpdateRoleRequestV1 = z.infer<typeof UpdateRoleRequestSchemaV1>;

package/dist/types/roles/v1/schemas/update-scope-request-schema-v1.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+/** Zod schema for the body of an update-scope-type request. */
+export declare const UpdateScopeRequestSchemaV1: z.ZodObject<{
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Patch request body for updating a scope type.
+ *
+ * Roles API 1.0 model inferred from {@link UpdateScopeRequestSchemaV1}, so
+ * `UpdateScopeRequestV1` and the runtime validator can never describe different shapes.
+ */
+export type UpdateScopeRequestV1 = z.infer<typeof UpdateScopeRequestSchemaV1>;

package/dist/types/roles/v1/schemas/update-system-request-schema-v1.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+/** Zod schema for the body of an update-system request. */
+export declare const UpdateSystemRequestSchemaV1: z.ZodObject<{
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    owners: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        accountIdentifier: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+/**
+ * Patch request body for updating a system.
+ *
+ * Roles API 1.0 model inferred from {@link UpdateSystemRequestSchemaV1}, so
+ * `UpdateSystemRequestV1` and the runtime validator can never describe different shapes.
+ */
+export type UpdateSystemRequestV1 = z.infer<typeof UpdateSystemRequestSchemaV1>;

package/dist/types/roles/v1/types.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Model types for Fusion Roles API version 1.0.
+ *
+ * Every type here is `z.infer` of the matching schema in `./schemas`. The direction
+ * of truth is Zod → TypeScript: the schemas validate at runtime and the types are
+ * derived from them, because TypeScript types are erased and cannot produce a
+ * validator. Nothing in this package declares an API shape twice.
+ *
+ * The names carry the API version they describe, so `ApiRoleV1` can never silently
+ * become the shape of a future API version. A Roles API 2.0 would add `ApiRoleV2`
+ * from a sibling `../v2` graph.
+ *
+ * This module is type-only, so re-exporting it costs nothing at runtime and pulls
+ * no schema module into a consumer's bundle.
+ *
+ * @packageDocumentation
+ */
+export type { AccessRoleMappingV1 } from './schemas/access-role-mapping-schema-v1';
+export type { ActivateAssignedClaimableRoleRequestV1 } from './schemas/activate-assigned-claimable-role-request-schema-v1';
+export type { AddClaimableRoleAccessRoleRequestV1 } from './schemas/add-claimable-role-access-role-request-schema-v1';
+export type { AddRoleAccessRoleRequestV1 } from './schemas/add-role-access-role-request-schema-v1';
+export type { ApiAccessRoleAssignmentV1 } from './schemas/api-access-role-assignment-schema-v1';
+export type { ApiAccessRoleMappingV1 } from './schemas/api-access-role-mapping-schema-v1';
+export type { ApiAccessRoleV1 } from './schemas/api-access-role-schema-v1';
+export type { ApiAccountAccessRoleAssignmentV1 } from './schemas/api-account-access-role-assignment-schema-v1';
+export type { ApiAccountAccessRoleV1 } from './schemas/api-account-access-role-schema-v1';
+export type { ApiAccountActiveAccessRoleAssignmentV1 } from './schemas/api-account-active-access-role-assignment-schema-v1';
+export type { ApiAccountClaimableRoleAssignmentV1 } from './schemas/api-account-claimable-role-assignment-schema-v1';
+export type { ApiAccountRoleAssignmentV1 } from './schemas/api-account-role-assignment-schema-v1';
+export type { ApiAccountV1 } from './schemas/api-account-schema-v1';
+export type { ApiBindingExecutionRecordV1 } from './schemas/api-binding-execution-record-schema-v1';
+export type { ApiBindingNotificationRecordV1 } from './schemas/api-binding-notification-record-schema-v1';
+export type { ApiClaimableAccessRoleMappingV1 } from './schemas/api-claimable-access-role-mapping-schema-v1';
+export type { ApiClaimableRoleAssignmentActivationV1 } from './schemas/api-claimable-role-assignment-activation-schema-v1';
+export type { ApiClaimableRoleAssignmentV1 } from './schemas/api-claimable-role-assignment-schema-v1';
+export type { ApiClaimableRoleScopeV1 } from './schemas/api-claimable-role-scope-schema-v1';
+export type { ApiClaimableRoleV1 } from './schemas/api-claimable-role-schema-v1';
+export type { ApiConsolidatedAssignmentEntryV1 } from './schemas/api-consolidated-assignment-entry-schema-v1';
+export type { ApiConsolidatedClaimableRoleAssignmentV1 } from './schemas/api-consolidated-claimable-role-assignment-schema-v1';
+export type { ApiConsolidatedClaimableRoleRefV1 } from './schemas/api-consolidated-claimable-role-ref-schema-v1';
+export type { ApiConsolidatedRoleAssignmentV1 } from './schemas/api-consolidated-role-assignment-schema-v1';
+export type { ApiExtendedAccessRoleV1 } from './schemas/api-extended-access-role-schema-v1';
+export type { ApiExtendedClaimableRoleAssignmentActivationV1 } from './schemas/api-extended-claimable-role-assignment-activation-schema-v1';
+export type { ApiOwnerV1 } from './schemas/api-owner-schema-v1';
+export type { ApiPagedCollectionV1 } from './schemas/api-paged-collection-schema-v1';
+export type { ApiPurgeBindingResultV1 } from './schemas/api-purge-binding-result-schema-v1';
+export type { ApiRoleAssignmentV1 } from './schemas/api-role-assignment-schema-v1';
+export type { ApiRoleBindingConfigurationStatusV1 } from './schemas/api-role-binding-configuration-status-schema-v1';
+export type { ApiRoleBindingConfigurationV1 } from './schemas/api-role-binding-configuration-schema-v1';
+export type { ApiRoleScopeV1 } from './schemas/api-role-scope-schema-v1';
+export type { ApiRoleV1 } from './schemas/api-role-schema-v1';
+export type { ApiScopeTypeV1 } from './schemas/api-scope-type-schema-v1';
+export type { ApiScopeV1 } from './schemas/api-scope-schema-v1';
+export type { ApiScopeValuesV1 } from './schemas/api-scope-values-schema-v1';
+export type { ApiSimpleClaimableRoleAssignmentV1 } from './schemas/api-simple-claimable-role-assignment-schema-v1';
+export type { ApiSimpleClaimableRoleV1 } from './schemas/api-simple-claimable-role-schema-v1';
+export type { ApiSimpleRoleAssignmentV1 } from './schemas/api-simple-role-assignment-schema-v1';
+export type { ApiSimpleRoleV1 } from './schemas/api-simple-role-schema-v1';
+export type { ApiSimpleSystemV1 } from './schemas/api-simple-system-schema-v1';
+export type { ApiSubscriptionTypeV1 } from './schemas/api-subscription-type-schema-v1';
+export type { ApiSystemV1 } from './schemas/api-system-schema-v1';
+export type { AssignAccessRoleRequestV1 } from './schemas/assign-access-role-request-schema-v1';
+export type { AssignClaimableRoleRequestV1 } from './schemas/assign-claimable-role-request-schema-v1';
+export type { AssignRoleRequestV1 } from './schemas/assign-role-request-schema-v1';
+export type { ClaimableRoleBindingV1 } from './schemas/claimable-role-binding-schema-v1';
+export type { CreateAccessRoleRequestV1 } from './schemas/create-access-role-request-schema-v1';
+export type { CreateBindingExecutionRecordRequestV1 } from './schemas/create-binding-execution-record-request-schema-v1';
+export type { CreateBindingExecutionRecordResponseV1 } from './schemas/create-binding-execution-record-response-schema-v1';
+export type { CreateBindingNotificationRecordRequestV1 } from './schemas/create-binding-notification-record-request-schema-v1';
+export type { CreateBindingNotificationRecordResponseV1 } from './schemas/create-binding-notification-record-response-schema-v1';
+export type { CreateClaimableRoleRequestV1 } from './schemas/create-claimable-role-request-schema-v1';
+export type { CreateRoleBindingConfigurationRequestV1 } from './schemas/create-role-binding-configuration-request-schema-v1';
+export type { CreateRoleRequestV1 } from './schemas/create-role-request-schema-v1';
+export type { CreateScopeTypeRequestV1 } from './schemas/create-scope-type-request-schema-v1';
+export type { DeleteRoleAssignmentsRequestV1 } from './schemas/delete-role-assignments-request-schema-v1';
+export type { EntraGroupBindingV1 } from './schemas/entra-group-binding-schema-v1';
+export type { EntraGroupV1 } from './schemas/entra-group-schema-v1';
+export type { ExpandV1 } from './schemas/expand-schema-v1';
+export type { FilterV1 } from './schemas/filter-schema-v1';
+export type { IncludeDeletedV1 } from './schemas/include-deleted-schema-v1';
+export type { OrgChartAssignEntryV1 } from './schemas/org-chart-assign-entry-schema-v1';
+export type { OrgChartAssignmentV1 } from './schemas/org-chart-assignment-schema-v1';
+export type { OrgChartBindingV1 } from './schemas/org-chart-binding-schema-v1';
+export type { OrgChartContextV1 } from './schemas/org-chart-context-schema-v1';
+export type { OrgChartMatchCriteriaV1 } from './schemas/org-chart-match-criteria-schema-v1';
+export type { OrgChartProfileV1 } from './schemas/org-chart-profile-schema-v1';
+export type { OrgChartRuleV1 } from './schemas/org-chart-rule-schema-v1';
+export type { OrgChartScopeV1 } from './schemas/org-chart-scope-schema-v1';
+export type { OwnerInfoV1 } from './schemas/owner-info-schema-v1';
+export type { RegisterSystemRequestV1 } from './schemas/register-system-request-schema-v1';
+export type { RequestClaimableRoleScopeV1 } from './schemas/request-claimable-role-scope-schema-v1';
+export type { RequestRoleScopeV1 } from './schemas/request-role-scope-schema-v1';
+export type { RequestScopeV1 } from './schemas/request-scope-schema-v1';
+export type { RoleBindingConfigurationBindingV1 } from './schemas/role-binding-configuration-binding-schema-v1';
+export type { RoleBindingV1 } from './schemas/role-binding-schema-v1';
+export type { ScopeBindingV1 } from './schemas/scope-binding-schema-v1';
+export type { SkipV1 } from './schemas/skip-schema-v1';
+export type { SubscriptionRequestV1 } from './schemas/subscription-request-schema-v1';
+export type { TopV1 } from './schemas/top-schema-v1';
+export type { UpdateAccessRoleAssignmentRequestV1 } from './schemas/update-access-role-assignment-request-schema-v1';
+export type { UpdateAccessRoleRequestV1 } from './schemas/update-access-role-request-schema-v1';
+export type { UpdateClaimableRoleAssignmentRequestV1 } from './schemas/update-claimable-role-assignment-request-schema-v1';
+export type { UpdateClaimableRoleRequestV1 } from './schemas/update-claimable-role-request-schema-v1';
+export type { UpdateRoleAssignmentRequestV1 } from './schemas/update-role-assignment-request-schema-v1';
+export type { UpdateRoleBindingConfigurationRequestV1 } from './schemas/update-role-binding-configuration-request-schema-v1';
+export type { UpdateRoleBindingConfigurationStatusRequestV1 } from './schemas/update-role-binding-configuration-status-request-schema-v1';
+export type { UpdateRoleRequestV1 } from './schemas/update-role-request-schema-v1';
+export type { UpdateScopeRequestV1 } from './schemas/update-scope-request-schema-v1';
+export type { UpdateSystemRequestV1 } from './schemas/update-system-request-schema-v1';

package/dist/types/types.d.ts

@@ -0,0 +1,173 @@
+import type { z } from 'zod';
+import type { ClientRequestInit, IHttpClient, StreamResponse } from '@equinor/fusion-framework-module-http/client';
+/**
+ * The argument and response schemas one concrete API version publishes.
+ *
+ * Pairing the two in a single entry is what makes the version a *single*
+ * discriminator: an endpoint cannot pick version 1.0 arguments and version 2.0
+ * response validation, because both are read from the same contract entry.
+ */
+export type ApiVersionSchemas = {
+    /** Schema validating the arguments this version accepts. */
+    args: z.ZodType;
+    /** Schema validating the response body this version publishes. */
+    response: z.ZodType;
+};
+/**
+ * An endpoint's version contract: concrete API version → the schemas it publishes.
+ *
+ * Keys are the *concrete* version values (`'1.0'`), never the aliases (`'v1'`),
+ * so an alias must be resolved before the contract can be indexed.
+ *
+ * @example
+ * ```ts
+ * const VersionContract = {
+ *   [ApiVersion.v1]: { args: z.object({ roleIdentifier: z.string() }), response: ApiRoleSchemaV1 },
+ * } as const satisfies ApiVersionContract;
+ * ```
+ */
+export type ApiVersionContract = Record<string, ApiVersionSchemas>;
+/**
+ * Projects a version contract onto its argument schemas, keyed by concrete version.
+ *
+ * The projection is what keeps a version lookup resolvable while the version is
+ * still generic: a single indexed access into a mapped type reduces, whereas the
+ * nested `TContract[TVersion]['args']` access stays deferred and breaks inference.
+ *
+ * @template TContract - The endpoint's version contract.
+ */
+export type ApiVersionArgSchemas<TContract extends ApiVersionContract> = {
+    [TVersion in keyof TContract]: TContract[TVersion]['args'];
+};
+/**
+ * Projects a version contract onto its response schemas, keyed by concrete version.
+ *
+ * @template TContract - The endpoint's version contract.
+ */
+export type ApiVersionResponseSchemas<TContract extends ApiVersionContract> = {
+    [TVersion in keyof TContract]: TContract[TVersion]['response'];
+};
+/**
+ * The arguments a caller passes for a specific version of an endpoint.
+ *
+ * Resolves through the contract entry for `TVersion` only, so versions never
+ * union their argument fields together.
+ *
+ * @template TContract - The endpoint's version contract.
+ * @template TVersion - Concrete API version to resolve.
+ */
+export type VersionedArgs<TContract extends ApiVersionContract, TVersion extends keyof TContract> = z.input<ApiVersionArgSchemas<TContract>[TVersion]>;
+/**
+ * The arguments of a specific version *after* the contract schema has parsed them.
+ *
+ * Request builders receive parsed arguments, so defaults and transforms applied
+ * by the schema are already in place.
+ *
+ * @template TContract - The endpoint's version contract.
+ * @template TVersion - Concrete API version to resolve.
+ */
+export type VersionedParsedArgs<TContract extends ApiVersionContract, TVersion extends keyof TContract> = z.infer<ApiVersionArgSchemas<TContract>[TVersion]>;
+/**
+ * The response body a specific version of an endpoint returns.
+ *
+ * @template TContract - The endpoint's version contract.
+ * @template TVersion - Concrete API version to resolve.
+ */
+export type VersionedResponse<TContract extends ApiVersionContract, TVersion extends keyof TContract> = z.infer<ApiVersionResponseSchemas<TContract>[TVersion]>;
+/**
+ * Tuple type representing the positional arguments passed to an HTTP client method.
+ *
+ * Endpoint functions in this package build the `[path, init]` pair that the HTTP
+ * client's `json()` or `json$()` method expects, so this type describes the
+ * hand-off between a generated request and the transport that executes it.
+ *
+ * @template TClient - The HTTP client type that will execute the request.
+ * @template TResult - The expected response body type.
+ */
+export type ApiClientArguments<TClient extends IHttpClient, TResult = unknown> = [
+    path: string,
+    init?: ClientRequestInit<TClient, TResult>
+];
+/**
+ * Maps HTTP client execution methods to their return types.
+ *
+ * - `json` — returns a `Promise` that resolves with the parsed JSON body.
+ * - `json$` — returns an RxJS-style `StreamResponse` observable.
+ *
+ * Every endpoint function is generic over `ClientMethod`, so a caller chooses
+ * between promise-based and observable-based consumption at the call site
+ * without losing response typing.
+ *
+ * @template T - The expected deserialized response body type.
+ */
+export type ClientMethod<T = unknown> = {
+    /** Fetch JSON data from a service as a promise. */
+    json: Promise<T>;
+    /** Fetch JSON data from a service as an observable stream. */
+    json$: StreamResponse<T>;
+};
+/** Union of available client method names (`'json' | 'json$'`). */
+export type ClientMethodType = keyof ClientMethod;
+/**
+ * Every identifier that names a single API version.
+ *
+ * A version is nameable three ways — by its key (`'v1'`), by the enum member
+ * (`ApiVersion.v1`), and by the raw version string (`'1.0'`). String enum members
+ * are nominal in TypeScript, so the raw string has to be spelled out through a
+ * template literal or callers could not pass `'1.0'` at all.
+ *
+ * @template TKey - The version key.
+ * @template TValue - The concrete version the key names.
+ */
+type ApiVersionAliases<TKey, TValue extends string> = (TKey & string) | TValue | `${TValue}`;
+/**
+ * Version identifiers an endpoint accepts, restricted to the versions it publishes.
+ *
+ * Use it to describe the version parameter of an endpoint, so callers may pass the
+ * version key (`'v1'`), the enum member (`ApiVersion.v1`), or the raw version
+ * value (`'1.0'`) — all three name the same contract entry.
+ *
+ * @example
+ * ```typescript
+ * enum ApiVersion {
+ *   v1 = '1.0',
+ *   v2 = '2.0',
+ * }
+ *
+ * type AllowedVersions = FilterAllowedApiVersions<typeof ApiVersion, ApiVersion.v1>;
+ * // 'v1' | ApiVersion.v1 | '1.0'
+ * ```
+ *
+ * @template TAvailableTypes - An object type that maps version keys to version values.
+ * @template TAllowedTypes - Keys or values of the versions the endpoint publishes.
+ * @returns A union of every identifier naming one of the allowed versions.
+ */
+export type FilterAllowedApiVersions<TAvailableTypes extends Record<string, string>, TAllowedTypes extends string | number | symbol = keyof TAvailableTypes> = {
+    [K in keyof TAvailableTypes]: K extends TAllowedTypes ? ApiVersionAliases<K, TAvailableTypes[K]> : TAvailableTypes[K] extends TAllowedTypes ? ApiVersionAliases<K, TAvailableTypes[K]> : never;
+}[keyof TAvailableTypes];
+/**
+ * Maps a version identifier that is not a key back onto the version it names.
+ *
+ * Both the enum member and its raw string resolve to the enum member, so a
+ * contract lookup gets the same key whichever spelling the caller used.
+ *
+ * @template TAvailableTypes - An object mapping version keys to version values.
+ * @template TVersion - The identifier to resolve.
+ */
+type ResolveApiVersionValue<TAvailableTypes extends Record<string, string>, TVersion extends string> = {
+    [K in keyof TAvailableTypes]: TVersion extends TAvailableTypes[K] | `${TAvailableTypes[K]}` ? TAvailableTypes[K] : never;
+}[keyof TAvailableTypes];
+/**
+ * Resolves a version identifier to the concrete API version it names.
+ *
+ * This is the type-level half of the version discriminator: `'v1'`, `'1.0'`, and
+ * `ApiVersion.v1` all resolve to the same concrete version, which then indexes an
+ * endpoint's version contract for both its argument and response types.
+ *
+ * @template TAvailableTypes - An object mapping API version keys to version strings.
+ * @template TVersion - The API version identifier to resolve.
+ * @template TAllowedTypes - The allowed API version identifiers.
+ * @returns The resolved API version if it is available and allowed, otherwise `never`.
+ */
+export type ExtractApiVersion<TAvailableTypes extends Record<string, string>, TVersion extends string, TAllowedTypes extends string | number | symbol = FilterAllowedApiVersions<TAvailableTypes>> = TVersion extends keyof TAvailableTypes ? TAvailableTypes[TVersion] : TVersion extends TAllowedTypes ? ResolveApiVersionValue<TAvailableTypes, TVersion> : never;
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,97 @@
+import type { z } from 'zod';
+import { type ResponseSelector } from '@equinor/fusion-framework-module-http/selectors';
+import type { ApiVersionContract, ExtractApiVersion, VersionedParsedArgs, VersionedResponse } from './types';
+/**
+ * Resolves an API version string from a named key or a raw version value.
+ *
+ * Endpoint functions accept both `'v1'` and `'1.0'`, so this lookup normalises
+ * the caller's version identifier before a request path or schema is selected.
+ * The version key is checked first; otherwise the value is matched directly.
+ *
+ * @template TApiVersions - Record mapping version keys to version strings.
+ * @template TVersion - The version key or value provided by the caller.
+ * @param apiVersions - Map of version keys to version strings.
+ * @param version - Version key or raw version string to resolve.
+ * @returns The resolved API version string.
+ * @throws {Error} When the version is neither a key nor a value of `apiVersions`.
+ *
+ * @example
+ * ```ts
+ * enum ApiVersion { v1 = '1.0', v2 = '2.0' }
+ * extractVersion(ApiVersion, 'v1'); // '1.0'
+ * extractVersion(ApiVersion, '1.0'); // '1.0'
+ * ```
+ */
+export declare const extractVersion: <TApiVersions extends Record<string, string>, TVersion extends string>(apiVersions: TApiVersions, version: TVersion) => ExtractApiVersion<TApiVersions, TVersion>;
+/**
+ * Creates a response selector that validates the HTTP response body with a Zod schema.
+ *
+ * Combines the HTTP module's `jsonSelector` with Zod parsing, so an endpoint
+ * rejects payloads the service contract does not allow instead of forwarding
+ * them to the caller as loosely typed data.
+ *
+ * @template Output - The validated output type produced by the schema.
+ * @param schema - The Zod schema used to parse and validate the response body.
+ * @returns A `ResponseSelector` that extracts JSON and runs it through `schema.parse`.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod';
+ * const RoleSchema = z.object({ id: z.string(), name: z.string() });
+ * const selector = schemaSelector(RoleSchema);
+ * ```
+ */
+export declare const schemaSelector: <Output>(schema: z.ZodSchema<Output>) => ResponseSelector<Output>;
+/**
+ * Validates an empty successful response without attempting to parse a JSON body.
+ *
+ * Use this selector for endpoints whose contract specifies an empty body with a success status
+ * other than `204 No Content`; `jsonSelector` only skips parsing for 204 responses.
+ *
+ * @param response - HTTP response whose success status must be validated.
+ * @returns A promise that resolves to `undefined` after a successful response.
+ * @throws {HttpJsonResponseError} When an unsuccessful response cannot be parsed as JSON.
+ */
+export declare const emptyResponseSelector: ResponseSelector<void>;
+/**
+ * Parses caller input with the argument schema a version contract publishes for `version`.
+ *
+ * Endpoints resolve the concrete version first and then look the schema up, so
+ * this helper keeps the parsed value typed by the *same* deferred version
+ * expression the request builders declare. Parsing inline instead would collapse
+ * the result to one version's concrete shape and break that association as soon
+ * as a second version is added.
+ *
+ * @template TContract - The endpoint's version contract.
+ * @template TVersion - Concrete API version to resolve.
+ * @param contract - Version contract to read the argument schema from.
+ * @param version - Concrete API version selecting the contract entry.
+ * @param input - Caller-supplied arguments.
+ * @returns The arguments parsed by the schema this version publishes.
+ * @throws {z.ZodError} When the input does not satisfy the version's argument schema.
+ *
+ * @example
+ * ```ts
+ * const args = parseVersionedArgs(VersionContract, apiVersion, input);
+ * ```
+ */
+export declare const parseVersionedArgs: <TContract extends ApiVersionContract, TVersion extends keyof TContract>(contract: TContract, version: TVersion, input: unknown) => VersionedParsedArgs<TContract, TVersion>;
+/**
+ * Builds a response selector from the schema a version contract publishes for `version`.
+ *
+ * Pairing the selector with the same contract entry the arguments were parsed
+ * from is what guarantees a request cannot be validated against another
+ * version's response shape.
+ *
+ * @template TContract - The endpoint's version contract.
+ * @template TVersion - Concrete API version to resolve.
+ * @param contract - Version contract to read the response schema from.
+ * @param version - Concrete API version selecting the contract entry.
+ * @returns A selector validating the response with this version's schema.
+ *
+ * @example
+ * ```ts
+ * const selector = versionedResponseSelector(VersionContract, apiVersion);
+ * ```
+ */
+export declare const versionedResponseSelector: <TContract extends ApiVersionContract, TVersion extends keyof TContract>(contract: TContract, version: TVersion) => ResponseSelector<VersionedResponse<TContract, TVersion>>;

package/dist/types/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "0.2.0";