@equinor/fusion-services 0.2.0

package/dist/types/roles/endpoints/roles-subscription.put.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 `putRolesSubscription` accepts for `PUT /subscriptions/roles-v2`.
+ *
+ * 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 PutRolesSubscriptionArg} and {@link PutRolesSubscriptionResponse}.
+ */
+type PutRolesSubscriptionVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `putRolesSubscription`, implementing `PUT /subscriptions/roles-v2`.
+ *
+ * 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<{
+            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>;
+        /** Response published by version 1.0. The upstream spec does not publish a response schema. */
+        readonly response: z.ZodUnknown;
+    };
+};
+/**
+ * Response body `putRolesSubscription` resolves for the selected API version.
+ *
+ * Version 1.0 publishes no response schema in the OpenAPI contract, so the type resolves to
+ * `unknown`.
+ */
+type PutRolesSubscriptionResponse<TVersion extends PutRolesSubscriptionVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `putRolesSubscription` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the request body fields of `SubscriptionRequestV1`.
+ *
+ * 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 PutRolesSubscriptionArg<TVersion extends PutRolesSubscriptionVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `putRolesSubscription` hands back once the request runs, for the selected API version
+ * and client method.
+ *
+ * `'json'` gives `Promise<PutRolesSubscriptionResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<PutRolesSubscriptionResponse<TVersion>>`, so promise and observable callers
+ * share one response type.
+ */
+type PutRolesSubscriptionResult<TVersion extends PutRolesSubscriptionVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<PutRolesSubscriptionResponse<TVersion>>[TMethod];
+/**
+ * Creates or renews a subscription to Fusion Roles V2 service events.
+ *
+ * Roles V2 operation: `PUT /subscriptions/roles-v2` — "Create or renew a subscription to role
+ * service events."
+ *
+ * Curried in two stages: `putRolesSubscription(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 PutRolesSubscriptionArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link PutRolesSubscriptionResult}.
+ *
+ * The version argument is the single discriminator: `'v1'` — equivalently `'1.0'` or
+ * `ApiVersion.v1` — selects the version-1.0 argument schema, passes the response body through
+ * unvalidated (the contract publishes no response schema), and sends `api-version=1.0` on the
+ * request.
+ *
+ * Roles V2 answers `200 OK`; the contract publishes no response schema, so the body is typed
+ * `unknown`. The call is an upsert: absent subscriptions are created, existing ones renewed.
+ * 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 PutRolesSubscriptionArg} and an optional
+ * `ClientRequestInit`, returning {@link PutRolesSubscriptionResult}.
+ * @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 { putRolesSubscription } from '@equinor/fusion-services/roles';
+ *
+ * const subscription = await putRolesSubscription('v1', httpClient)({
+ *   identifier: 'my-app-subscription',
+ *   type: 'Persistent',
+ * });
+ * ```
+ */
+declare const putRolesSubscription: <TVersion extends PutRolesSubscriptionVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input?: PutRolesSubscriptionArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, PutRolesSubscriptionResponse<ExtractApiVersion<TVersion>>>) => PutRolesSubscriptionResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type PutRolesSubscriptionArg, type PutRolesSubscriptionResponse, type PutRolesSubscriptionResult, type PutRolesSubscriptionVersion, putRolesSubscription, };

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

@@ -0,0 +1,197 @@
+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 `listRoles` accepts for `GET /roles`.
+ *
+ * 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 ListRolesArg} and {@link ListRolesResponse}.
+ */
+type ListRolesVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listRoles`, implementing `GET /roles`.
+ *
+ * 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>;
+            expand: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodObject<{
+            totalCount: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            count: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+            nextPage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            prevPage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            value: z.ZodOptional<z.ZodArray<z.ZodType<{
+                id?: string | undefined;
+                name?: string | undefined;
+                displayName?: string | undefined;
+                description?: string | undefined;
+                system?: {
+                    id?: string | undefined;
+                    name?: string | undefined;
+                } | null | undefined;
+            } & {
+                accessRoleMappings?: {
+                    accessRole?: {
+                        id?: string | undefined;
+                        name?: string | undefined;
+                        description?: string | undefined;
+                        scopeType?: {
+                            id?: string | undefined;
+                            name?: string | undefined;
+                            description?: string | null | undefined;
+                        } | null | undefined;
+                    } | undefined;
+                    reason?: string | undefined;
+                }[] | null | undefined;
+                createdBy?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | undefined;
+                createdDate?: string | undefined;
+                updatedBy?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | null | undefined;
+                updatedDate?: string | null | undefined;
+            }, unknown, z.core.$ZodTypeInternals<{
+                id?: string | undefined;
+                name?: string | undefined;
+                displayName?: string | undefined;
+                description?: string | undefined;
+                system?: {
+                    id?: string | undefined;
+                    name?: string | undefined;
+                } | null | undefined;
+            } & {
+                accessRoleMappings?: {
+                    accessRole?: {
+                        id?: string | undefined;
+                        name?: string | undefined;
+                        description?: string | undefined;
+                        scopeType?: {
+                            id?: string | undefined;
+                            name?: string | undefined;
+                            description?: string | null | undefined;
+                        } | null | undefined;
+                    } | undefined;
+                    reason?: string | undefined;
+                }[] | null | undefined;
+                createdBy?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | undefined;
+                createdDate?: string | undefined;
+                updatedBy?: {
+                    azureUniqueId?: string | null | undefined;
+                    mail?: string | null | undefined;
+                    displayName?: string | undefined;
+                    upn?: string | null | undefined;
+                    accountType?: string | undefined;
+                    accountClassification?: string | null | undefined;
+                } | null | undefined;
+                updatedDate?: string | null | undefined;
+            }, unknown>>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `listRoles` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiPagedCollectionV1<ApiRoleV1>`, inferred from
+ * `apiPagedCollectionSchemaV1(ApiRoleSchemaV1)` — the very schema that validates the `200 OK`
+ * body at runtime.
+ */
+type ListRolesResponse<TVersion extends ListRolesVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listRoles` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the optional query options `top`, `skip`, `expand`.
+ *
+ * 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 ListRolesArg<TVersion extends ListRolesVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listRoles` hands back once the request runs, for the selected API version and client
+ * method.
+ *
+ * `'json'` gives `Promise<ListRolesResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<ListRolesResponse<TVersion>>`, so promise and observable callers share one
+ * response type.
+ */
+type ListRolesResult<TVersion extends ListRolesVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListRolesResponse<TVersion>>[TMethod];
+/**
+ * Lists the roles published by the Roles service.
+ *
+ * Roles V2 operation: `GET /roles` — "Get all roles."
+ *
+ * Curried in two stages: `listRoles(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 ListRolesArg}
+ * plus an optional `ClientRequestInit`, and gives back {@link ListRolesResult}.
+ *
+ * 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(ApiRoleSchemaV1)`, 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 `expand` is sent as `$expand` to inline related resources.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiPagedCollectionV1<ApiRoleV1>`.
+ *
+ * Related: `getRole` fetches a single entry by identifier, and `assignRole` grants a role to a
+ * user or application account.
+ *
+ * @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 ListRolesArg} and an optional `ClientRequestInit`,
+ * returning {@link ListRolesResult}.
+ * @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 { listRoles } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listRoles('v1', httpClient)({ top: 25 });
+ * ```
+ *
+ * @example
+ * Observable form: pass `json$` to receive a `StreamResponse` instead of a promise.
+ * ```ts
+ * listRoles('v1', httpClient, 'json$')({ top: 25 }).subscribe(console.log);
+ * ```
+ */
+declare const listRoles: <TVersion extends ListRolesVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input?: ListRolesArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListRolesResponse<ExtractApiVersion<TVersion>>>) => ListRolesResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListRolesArg, type ListRolesResponse, type ListRolesResult, type ListRolesVersion, listRoles, };

package/dist/types/roles/endpoints/roles.post.d.ts

@@ -0,0 +1,152 @@
+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 `createRole` accepts for `POST /roles`.
+ *
+ * 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 CreateRoleArg} and {@link CreateRoleResponse}.
+ */
+type CreateRoleVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `createRole`, implementing `POST /roles`.
+ *
+ * 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<{
+            name: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            systemIdentifier: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            accessRoleMappings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                accessRoleIdentifier: z.ZodOptional<z.ZodString>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodIntersection<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            displayName: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            system: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                name: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            accessRoleMappings: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                accessRole: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                    scopeType: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                        id: z.ZodOptional<z.ZodString>;
+                        name: z.ZodOptional<z.ZodString>;
+                        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>>;
+            createdBy: z.ZodOptional<z.ZodObject<{
+                azureUniqueId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                mail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                displayName: z.ZodOptional<z.ZodString>;
+                upn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                accountType: z.ZodOptional<z.ZodString>;
+                accountClassification: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+            createdDate: z.ZodOptional<z.ZodString>;
+            updatedBy: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                azureUniqueId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                mail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                displayName: z.ZodOptional<z.ZodString>;
+                upn: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                accountType: z.ZodOptional<z.ZodString>;
+                accountClassification: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+            updatedDate: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    };
+};
+/**
+ * Response body `createRole` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiRoleV1`, inferred from `ApiRoleSchemaV1` — the very schema that
+ * validates the `201 Created` body at runtime.
+ */
+type CreateRoleResponse<TVersion extends CreateRoleVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `createRole` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the request body fields of `CreateRoleRequestV1`.
+ *
+ * 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 CreateRoleArg<TVersion extends CreateRoleVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `createRole` hands back once the request runs, for the selected API version and client
+ * method.
+ *
+ * `'json'` gives `Promise<CreateRoleResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<CreateRoleResponse<TVersion>>`, so promise and observable callers share one
+ * response type.
+ */
+type CreateRoleResult<TVersion extends CreateRoleVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<CreateRoleResponse<TVersion>>[TMethod];
+/**
+ * Creates a role in the Fusion Roles V2 catalogue, optionally with its access role mappings.
+ *
+ * Roles V2 operation: `POST /roles` — "Create a new role."
+ *
+ * Curried in two stages: `createRole(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 CreateRoleArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link CreateRoleResult}.
+ *
+ * The version argument is the single discriminator: `'v1'` — equivalently `'1.0'` or
+ * `ApiVersion.v1` — selects the version-1.0 argument schema, validates the response with
+ * `ApiRoleSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `201 Created`; the body is typed `ApiRoleV1`. The contract declares `403
+ * Forbidden` for callers the Roles service does not authorise for this operation.
+ *
+ * Related: `addRoleAccessRoles` maps access roles onto the new role, and `assignRole` grants it
+ * to a user or application account.
+ *
+ * @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 CreateRoleArg} and an optional `ClientRequestInit`,
+ * returning {@link CreateRoleResult}.
+ * @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 { createRole } from '@equinor/fusion-services/roles';
+ *
+ * const role = await createRole('v1', httpClient)({
+ *   name: 'reader',
+ *   displayName: 'Reader',
+ *   systemIdentifier: 'fusion-core',
+ * });
+ * ```
+ */
+declare const createRole: <TVersion extends CreateRoleVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input?: CreateRoleArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, CreateRoleResponse<ExtractApiVersion<TVersion>>>) => CreateRoleResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type CreateRoleArg, type CreateRoleResponse, type CreateRoleResult, type CreateRoleVersion, createRole, };

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

package/dist/types/roles/endpoints/scope-type.get.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 `getScopeType` accepts for `GET /scope-types/{scopeTypeIdentifier}`.
+ *
+ * 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 GetScopeTypeArg} and {@link GetScopeTypeResponse}.
+ */
+type GetScopeTypeVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `getScopeType`, implementing `GET /scope-types/{scopeTypeIdentifier}`.
+ *
+ * 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<{
+            scopeTypeIdentifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `getScopeType` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiScopeTypeV1`, inferred from `ApiScopeTypeSchemaV1` — the very
+ * schema that validates the `200 OK` body at runtime.
+ */
+type GetScopeTypeResponse<TVersion extends GetScopeTypeVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `getScopeType` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `scopeTypeIdentifier`.
+ *
+ * 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 GetScopeTypeArg<TVersion extends GetScopeTypeVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `getScopeType` hands back once the request runs, for the selected API version and client
+ * method.
+ *
+ * `'json'` gives `Promise<GetScopeTypeResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<GetScopeTypeResponse<TVersion>>`, so promise and observable callers share one
+ * response type.
+ */
+type GetScopeTypeResult<TVersion extends GetScopeTypeVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<GetScopeTypeResponse<TVersion>>[TMethod];
+/**
+ * Fetches one scope type by its UUID or unique scope type name.
+ *
+ * Roles V2 operation: `GET /scope-types/{scopeTypeIdentifier}` — "Get a scope type by
+ * identifier."
+ *
+ * Curried in two stages: `getScopeType(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 GetScopeTypeArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link GetScopeTypeResult}.
+ *
+ * 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
+ * `ApiScopeTypeSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiScopeTypeV1`.
+ *
+ * @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 GetScopeTypeArg} and an optional
+ * `ClientRequestInit`, returning {@link GetScopeTypeResult}.
+ * @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 { getScopeType } from '@equinor/fusion-services/roles';
+ *
+ * const scopeType = await getScopeType('v1', httpClient)({ scopeTypeIdentifier: 'project' });
+ * ```
+ */
+declare const getScopeType: <TVersion extends GetScopeTypeVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: GetScopeTypeArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, GetScopeTypeResponse<ExtractApiVersion<TVersion>>>) => GetScopeTypeResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type GetScopeTypeArg, type GetScopeTypeResponse, type GetScopeTypeResult, type GetScopeTypeVersion, getScopeType, };