@equinor/fusion-services 0.2.0

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

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

@@ -0,0 +1,123 @@
+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 `updateSystem` accepts for `PATCH /systems/{systemIdentifier}`.
+ *
+ * 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 UpdateSystemArg} and {@link UpdateSystemResponse}.
+ */
+type UpdateSystemVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `updateSystem`, implementing `PATCH /systems/{systemIdentifier}`.
+ *
+ * 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<{
+            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>>>>;
+            systemIdentifier: z.ZodString;
+        }, z.core.$strip>;
+        /** Response published by version 1.0 of this operation. */
+        readonly response: z.ZodIntersection<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            owners: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                reason: z.ZodOptional<z.ZodString>;
+                account: 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>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    };
+};
+/**
+ * Response body `updateSystem` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiSystemV1`, inferred from `ApiSystemSchemaV1` — the very schema
+ * that validates the `200 OK` body at runtime.
+ */
+type UpdateSystemResponse<TVersion extends UpdateSystemVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `updateSystem` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the path identifier `systemIdentifier`, and the request body fields of
+ * `UpdateSystemRequestV1`.
+ *
+ * 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 UpdateSystemArg<TVersion extends UpdateSystemVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `updateSystem` hands back once the request runs, for the selected API version and client
+ * method.
+ *
+ * `'json'` gives `Promise<UpdateSystemResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<UpdateSystemResponse<TVersion>>`, so promise and observable callers share one
+ * response type.
+ */
+type UpdateSystemResult<TVersion extends UpdateSystemVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<UpdateSystemResponse<TVersion>>[TMethod];
+/**
+ * Updates the description or owner list of a registered system.
+ *
+ * Roles V2 operation: `PATCH /systems/{systemIdentifier}` — "Update an existing system."
+ *
+ * Curried in two stages: `updateSystem(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 UpdateSystemArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link UpdateSystemResult}.
+ *
+ * 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
+ * `ApiSystemSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `200 OK`; the body is typed `ApiSystemV1`. Fields left out of the arguments
+ * are not sent, so they keep their stored values. The contract declares `403 Forbidden` for
+ * callers the Roles service does not authorise for this operation.
+ *
+ * @template TVersion - Roles API version identifier: `'v1'`, `'1.0'`, or `ApiVersion.v1`.
+ * @template TMethod - Execution method: `'json'` for a promise, `'json$'` for an observable.
+ * @param version - API version selecting the request path, the argument schema, and the
+ * response schema.
+ * @param client - HTTP client that executes the request against the Roles service.
+ * @param method - Execution method, defaulting to `'json'`.
+ * @returns A request function taking {@link UpdateSystemArg} and an optional
+ * `ClientRequestInit`, returning {@link UpdateSystemResult}.
+ * @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 { updateSystem } from '@equinor/fusion-services/roles';
+ *
+ * const system = await updateSystem('v1', httpClient)({
+ *   systemIdentifier: 'fusion-core',
+ *   description: 'Fusion core platform',
+ * });
+ * ```
+ */
+declare const updateSystem: <TVersion extends UpdateSystemVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input: UpdateSystemArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, UpdateSystemResponse<ExtractApiVersion<TVersion>>>) => UpdateSystemResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type UpdateSystemArg, type UpdateSystemResponse, type UpdateSystemResult, type UpdateSystemVersion, updateSystem, };

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

@@ -0,0 +1,138 @@
+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 `listSystems` accepts for `GET /systems`.
+ *
+ * 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 ListSystemsArg} and {@link ListSystemsResponse}.
+ */
+type ListSystemsVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `listSystems`, implementing `GET /systems`.
+ *
+ * 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>;
+        }, 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;
+            } & {
+                description?: string | undefined;
+                owners?: {
+                    reason?: string | undefined;
+                    account?: {
+                        azureUniqueId?: string | null | undefined;
+                        mail?: string | null | undefined;
+                        displayName?: string | undefined;
+                        upn?: string | null | undefined;
+                        accountType?: string | undefined;
+                        accountClassification?: string | null | undefined;
+                    } | undefined;
+                }[] | undefined;
+            }, unknown, z.core.$ZodTypeInternals<{
+                id?: string | undefined;
+                name?: string | undefined;
+            } & {
+                description?: string | undefined;
+                owners?: {
+                    reason?: string | undefined;
+                    account?: {
+                        azureUniqueId?: string | null | undefined;
+                        mail?: string | null | undefined;
+                        displayName?: string | undefined;
+                        upn?: string | null | undefined;
+                        accountType?: string | undefined;
+                        accountClassification?: string | null | undefined;
+                    } | undefined;
+                }[] | undefined;
+            }, unknown>>>>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Response body `listSystems` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiPagedCollectionV1<ApiSystemV1>`, inferred from
+ * `apiPagedCollectionSchemaV1(ApiSystemSchemaV1)` — the very schema that validates the `200 OK`
+ * body at runtime.
+ */
+type ListSystemsResponse<TVersion extends ListSystemsVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `listSystems` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts 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 ListSystemsArg<TVersion extends ListSystemsVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `listSystems` hands back once the request runs, for the selected API version and client
+ * method.
+ *
+ * `'json'` gives `Promise<ListSystemsResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<ListSystemsResponse<TVersion>>`, so promise and observable callers share one
+ * response type.
+ */
+type ListSystemsResult<TVersion extends ListSystemsVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<ListSystemsResponse<TVersion>>[TMethod];
+/**
+ * Lists the systems registered with the Roles service.
+ *
+ * Roles V2 operation: `GET /systems` — "Get all systems."
+ *
+ * Curried in two stages: `listSystems(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 ListSystemsArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link ListSystemsResult}.
+ *
+ * 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(ApiSystemSchemaV1)`, 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<ApiSystemV1>`.
+ *
+ * @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 ListSystemsArg} and an optional
+ * `ClientRequestInit`, returning {@link ListSystemsResult}.
+ * @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 { listSystems } from '@equinor/fusion-services/roles';
+ *
+ * const page = await listSystems('v1', httpClient)({ top: 25 });
+ * ```
+ */
+declare const listSystems: <TVersion extends ListSystemsVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input?: ListSystemsArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, ListSystemsResponse<ExtractApiVersion<TVersion>>>) => ListSystemsResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type ListSystemsArg, type ListSystemsResponse, type ListSystemsResult, type ListSystemsVersion, listSystems, };

package/dist/types/roles/endpoints/systems.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 `createSystem` accepts for `POST /systems`.
+ *
+ * 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 CreateSystemArg} and {@link CreateSystemResponse}.
+ */
+type CreateSystemVersion = FilterAllowedApiVersions<AvailableVersions>;
+/**
+ * Version contract for `createSystem`, implementing `POST /systems`.
+ *
+ * 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>;
+            description: z.ZodOptional<z.ZodString>;
+            owners: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                accountIdentifier: 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>;
+        }, z.core.$strip>, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            owners: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                reason: z.ZodOptional<z.ZodString>;
+                account: 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>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    };
+};
+/**
+ * Response body `createSystem` resolves for the selected API version.
+ *
+ * Version 1.0 resolves to `ApiSystemV1`, inferred from `ApiSystemSchemaV1` — the very schema
+ * that validates the `201 Created` body at runtime.
+ */
+type CreateSystemResponse<TVersion extends CreateSystemVersion> = VersionedResponse<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * Arguments `createSystem` accepts, resolved from the selected API version.
+ *
+ * Version 1.0 accepts the request body fields of `RegisterSystemRequestV1`.
+ *
+ * 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 CreateSystemArg<TVersion extends CreateSystemVersion> = VersionedArgs<typeof VersionContract, ExtractApiVersion<TVersion>>;
+/**
+ * What `createSystem` hands back once the request runs, for the selected API version and client
+ * method.
+ *
+ * `'json'` gives `Promise<CreateSystemResponse<TVersion>>` and `'json$'` gives
+ * `StreamResponse<CreateSystemResponse<TVersion>>`, so promise and observable callers share one
+ * response type.
+ */
+type CreateSystemResult<TVersion extends CreateSystemVersion, TMethod extends ClientMethodType = 'json'> = ClientMethod<CreateSystemResponse<TVersion>>[TMethod];
+/**
+ * Registers a system with the Fusion Roles V2 service.
+ *
+ * Roles V2 operation: `POST /systems` — "Create a new system."
+ *
+ * Curried in two stages: `createSystem(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 CreateSystemArg} plus an optional `ClientRequestInit`, and gives back
+ * {@link CreateSystemResult}.
+ *
+ * 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
+ * `ApiSystemSchemaV1`, and sends `api-version=1.0` on the request.
+ *
+ * Roles V2 answers `201 Created`; the body is typed `ApiSystemV1`. A colliding name answers
+ * `409 Conflict`. The contract declares `403 Forbidden` for callers the Roles service does not
+ * authorise for this operation.
+ *
+ * @template TVersion - Roles API version identifier: `'v1'`, `'1.0'`, or `ApiVersion.v1`.
+ * @template TMethod - Execution method: `'json'` for a promise, `'json$'` for an observable.
+ * @param version - API version selecting the request path, the argument schema, and the
+ * response schema.
+ * @param client - HTTP client that executes the request against the Roles service.
+ * @param method - Execution method, defaulting to `'json'`.
+ * @returns A request function taking {@link CreateSystemArg} and an optional
+ * `ClientRequestInit`, returning {@link CreateSystemResult}.
+ * @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 { createSystem } from '@equinor/fusion-services/roles';
+ *
+ * const system = await createSystem('v1', httpClient)({
+ *   name: 'fusion-core',
+ *   description: 'Fusion core platform',
+ * });
+ * ```
+ */
+declare const createSystem: <TVersion extends CreateSystemVersion, TMethod extends ClientMethodType = 'json'>(version: TVersion, client: IHttpClient, method?: TMethod) => (input?: CreateSystemArg<ExtractApiVersion<TVersion>>, init?: ClientRequestInit<IHttpClient, CreateSystemResponse<ExtractApiVersion<TVersion>>>) => CreateSystemResult<ExtractApiVersion<TVersion>, TMethod>;
+export { type CreateSystemArg, type CreateSystemResponse, type CreateSystemResult, type CreateSystemVersion, createSystem, };