@distilled.cloud/stackit 0.0.0-stage → 1.0.0-rc.14

package/src/services/run_command.ts

@@ -0,0 +1,413 @@
+import * as API from "@distilled.cloud/core/api";
+import * as C from "@distilled.cloud/core/category";
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-stackit). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import { UnknownStackitError } from "../errors.ts";
+import { StackitProtocol, type StackitOpError, type StackitOpContext } from "../protocol.ts";
+import * as Retry from "../retry.ts";
+import * as T from "../traits.ts";
+
+export type { StackitOpError, StackitOpContext };
+
+export class BadRequest
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<BadRequest>()("BadRequest", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 400 }],
+  ) {}
+
+export class NotFound
+  extends /*@__PURE__*/ T.applyErrorMatchers(
+    /*@__PURE__*/ S.TaggedError<NotFound>()("NotFound", {
+      code: S.Number,
+      message: S.String,
+    }).pipe(C.withBadRequestError),
+    [{ status: 404 }],
+  ) {}
+
+export type CreateCommandRequestParametersMap = { [key: string]: string | undefined };
+export const CreateCommandRequestParametersMap = /*@__PURE__*/ S.Record(
+  S.String,
+  S.String,
+) as any as S.Schema<CreateCommandRequestParametersMap>;
+
+export interface CreateCommandRequest {
+  /** ID of the project */
+  projectId: string;
+  /** region */
+  region: string;
+  /** Server ID of the machine */
+  serverId: string;
+  commandTemplateName: string;
+  parameters?: CreateCommandRequestParametersMap;
+}
+export const CreateCommandRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    commandTemplateName: S.String,
+    parameters: S.optional(CreateCommandRequestParametersMap),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/commands",
+      code: 200,
+      baseUrl: "https://run-command.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "CreateCommandRequest" }) as any as S.Schema<CreateCommandRequest>;
+
+export interface NewCommandResponse {
+  id?: number;
+}
+export const NewCommandResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.Number),
+  }),
+).annotate({ identifier: "NewCommandResponse" }) as any as S.Schema<NewCommandResponse>;
+
+export interface GetCommandRequest {
+  /** ID of the project */
+  projectId: string;
+  /** region */
+  region: string;
+  /** Server ID of the machine */
+  serverId: string;
+  /** ID of the command */
+  commandId: string;
+}
+export const GetCommandRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    commandId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/commands/{commandId}",
+      code: 200,
+      baseUrl: "https://run-command.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "GetCommandRequest" }) as any as S.Schema<GetCommandRequest>;
+
+export type CommandDetailsStatus = "pending" | "running" | "completed" | "failed";
+export const CommandDetailsStatus = S.String;
+
+export interface CommandDetails {
+  commandTemplateName?: string;
+  commandTemplateTitle?: string;
+  exitCode?: number;
+  finishedAt?: string;
+  id?: number;
+  output?: string;
+  script?: string;
+  startedAt?: string;
+  status?: CommandDetailsStatus;
+}
+export const CommandDetails = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    commandTemplateName: S.optional(S.String),
+    commandTemplateTitle: S.optional(S.String),
+    exitCode: S.optional(S.Number),
+    finishedAt: S.optional(S.String),
+    id: S.optional(S.Number),
+    output: S.optional(S.String),
+    script: S.optional(S.String),
+    startedAt: S.optional(S.String),
+    status: S.optional(CommandDetailsStatus),
+  }),
+).annotate({ identifier: "CommandDetails" }) as any as S.Schema<CommandDetails>;
+
+export interface GetCommandTemplateRequest {
+  /** ID of the project */
+  projectId: string;
+  /** region */
+  region: string;
+  /** Server ID of the machine */
+  serverId: string;
+  /** Name of the template */
+  commandTemplateName: string;
+}
+export const GetCommandTemplateRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+    commandTemplateName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/command-templates/{commandTemplateName}",
+      code: 200,
+      baseUrl: "https://run-command.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "GetCommandTemplateRequest",
+}) as any as S.Schema<GetCommandTemplateRequest>;
+
+export type CommandTemplateSchemaOsTypeList = Array<string>;
+export const CommandTemplateSchemaOsTypeList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CommandTemplateSchemaOsTypeList>;
+
+export interface Field {
+  default?: string;
+  description?: string;
+  maxLen?: number;
+  minLen?: number;
+  readOnly?: boolean;
+  title?: string;
+  type?: string;
+}
+export const Field = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    default: S.optional(S.String),
+    description: S.optional(S.String),
+    maxLen: S.optional(S.Number),
+    minLen: S.optional(S.Number),
+    readOnly: S.optional(S.Boolean),
+    title: S.optional(S.String),
+    type: S.optional(S.String),
+  }),
+).annotate({ identifier: "Field" }) as any as S.Schema<Field>;
+
+export type PropertiesRequiredList = Array<string>;
+export const PropertiesRequiredList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<PropertiesRequiredList>;
+
+export interface Properties {
+  ConfirmPassword?: Field;
+  Password?: Field;
+  Script?: Field;
+  Username?: Field;
+  required?: PropertiesRequiredList;
+  type?: string;
+}
+export const Properties = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ConfirmPassword: S.optional(Field),
+    Password: S.optional(Field),
+    Script: S.optional(Field),
+    Username: S.optional(Field),
+    required: S.optional(PropertiesRequiredList),
+    type: S.optional(S.String),
+  }),
+).annotate({ identifier: "Properties" }) as any as S.Schema<Properties>;
+
+export interface ParametersSchema {
+  properties?: Properties;
+}
+export const ParametersSchema = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    properties: S.optional(Properties),
+  }),
+).annotate({ identifier: "ParametersSchema" }) as any as S.Schema<ParametersSchema>;
+
+export interface CommandTemplateSchema {
+  description?: string;
+  name?: string;
+  osType?: CommandTemplateSchemaOsTypeList;
+  parametersSchema?: ParametersSchema;
+  title?: string;
+}
+export const CommandTemplateSchema = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    description: S.optional(S.String),
+    name: S.optional(S.String),
+    osType: S.optional(CommandTemplateSchemaOsTypeList),
+    parametersSchema: S.optional(ParametersSchema),
+    title: S.optional(S.String),
+  }),
+).annotate({ identifier: "CommandTemplateSchema" }) as any as S.Schema<CommandTemplateSchema>;
+
+export interface ListCommandsRequest {
+  /** ID of the project */
+  projectId: string;
+  /** region */
+  region: string;
+  /** Server ID of the machine */
+  serverId: string;
+}
+export const ListCommandsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    projectId: S.String.pipe(T.Label()),
+    region: S.String.pipe(T.Label()),
+    serverId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/projects/{projectId}/regions/{region}/servers/{serverId}/commands",
+      code: 200,
+      baseUrl: "https://run-command.api.stackit.cloud",
+    }),
+  ),
+).annotate({ identifier: "ListCommandsRequest" }) as any as S.Schema<ListCommandsRequest>;
+
+export type CommandsStatus = "pending" | "running" | "completed" | "failed";
+export const CommandsStatus = S.String;
+
+export interface Commands {
+  commandTemplateName?: string;
+  commandTemplateTitle?: string;
+  finishedAt?: string;
+  id?: number;
+  startedAt?: string;
+  status?: CommandsStatus;
+}
+export const Commands = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    commandTemplateName: S.optional(S.String),
+    commandTemplateTitle: S.optional(S.String),
+    finishedAt: S.optional(S.String),
+    id: S.optional(S.Number),
+    startedAt: S.optional(S.String),
+    status: S.optional(CommandsStatus),
+  }),
+).annotate({ identifier: "Commands" }) as any as S.Schema<Commands>;
+
+export type GetCommandsResponseItemsList = Array<Commands>;
+export const GetCommandsResponseItemsList = /*@__PURE__*/ S.Array(
+  Commands,
+) as any as S.Schema<GetCommandsResponseItemsList>;
+
+export interface GetCommandsResponse {
+  items?: GetCommandsResponseItemsList;
+}
+export const GetCommandsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: S.optional(GetCommandsResponseItemsList),
+  }),
+).annotate({ identifier: "GetCommandsResponse" }) as any as S.Schema<GetCommandsResponse>;
+
+export interface ListCommandTemplatesRequest {
+  /** The type of the Operating System (windows or linux). If not provided will return data for all OS types. */
+  osType?: string;
+}
+export const ListCommandTemplatesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    osType: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/v2/command-templates",
+      code: 200,
+      baseUrl: "https://run-command.api.stackit.cloud",
+    }),
+  ),
+).annotate({
+  identifier: "ListCommandTemplatesRequest",
+}) as any as S.Schema<ListCommandTemplatesRequest>;
+
+export type CommandTemplateOsTypeList = Array<string>;
+export const CommandTemplateOsTypeList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CommandTemplateOsTypeList>;
+
+export interface CommandTemplate {
+  name?: string;
+  osType?: CommandTemplateOsTypeList;
+  title?: string;
+}
+export const CommandTemplate = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    osType: S.optional(CommandTemplateOsTypeList),
+    title: S.optional(S.String),
+  }),
+).annotate({ identifier: "CommandTemplate" }) as any as S.Schema<CommandTemplate>;
+
+export type CommandTemplateResponseItemsList = Array<CommandTemplate>;
+export const CommandTemplateResponseItemsList = /*@__PURE__*/ S.Array(
+  CommandTemplate,
+) as any as S.Schema<CommandTemplateResponseItemsList>;
+
+export interface CommandTemplateResponse {
+  items?: CommandTemplateResponseItemsList;
+}
+export const CommandTemplateResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    items: S.optional(CommandTemplateResponseItemsList),
+  }),
+).annotate({ identifier: "CommandTemplateResponse" }) as any as S.Schema<CommandTemplateResponse>;
+
+export type CreateCommandError = BadRequest | NotFound | StackitOpError;
+/** Creates a new command for execution */
+export const createCommand: API.OperationMethod<
+  CreateCommandRequest,
+  NewCommandResponse,
+  CreateCommandError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateCommandRequest,
+  output: NewCommandResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetCommandError = BadRequest | NotFound | StackitOpError;
+/** Returns details about a command */
+export const getCommand: API.OperationMethod<
+  GetCommandRequest,
+  CommandDetails,
+  GetCommandError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetCommandRequest,
+  output: CommandDetails,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetCommandTemplateError = BadRequest | NotFound | StackitOpError;
+/** Returns details about a command template */
+export const getCommandTemplate: API.OperationMethod<
+  GetCommandTemplateRequest,
+  CommandTemplateSchema,
+  GetCommandTemplateError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetCommandTemplateRequest,
+  output: CommandTemplateSchema,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListCommandsError = BadRequest | NotFound | StackitOpError;
+/** Returns a list of commands */
+export const listCommands: API.OperationMethod<
+  ListCommandsRequest,
+  GetCommandsResponse,
+  ListCommandsError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListCommandsRequest,
+  output: GetCommandsResponse,
+  errors: [BadRequest, NotFound, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListCommandTemplatesError = BadRequest | StackitOpError;
+/** Returns a list of command templates */
+export const listCommandTemplates: API.OperationMethod<
+  ListCommandTemplatesRequest,
+  CommandTemplateResponse,
+  ListCommandTemplatesError,
+  StackitOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListCommandTemplatesRequest,
+  output: CommandTemplateResponse,
+  errors: [BadRequest, UnknownStackitError],
+  protocol: StackitProtocol,
+  retry: Retry.Retry,
+}));