@distilled.cloud/daytona 0.0.0-placeholder → 1.0.0-rc.13

package/src/services/port.ts

@@ -0,0 +1,87 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface GetPortsRequest {}
+export const GetPortsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(T.Http({ method: "GET", uri: "/port", code: 200 })),
+).annotate({
+  identifier: "GetPortsRequest",
+}) as any as S.Schema<GetPortsRequest>;
+
+export type PortListPortsList = Array<number>;
+export const PortListPortsList = /*@__PURE__*/ S.Array(
+  S.Number,
+) as any as S.Schema<PortListPortsList>;
+
+export interface PortList {
+  ports?: PortListPortsList;
+}
+export const PortList = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    ports: S.optional(PortListPortsList),
+  }),
+).annotate({ identifier: "PortList" }) as any as S.Schema<PortList>;
+
+export interface IsPortInUseRequest {
+  /** Port number (3000-9999) */
+  port: number;
+}
+export const IsPortInUseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    port: S.Number.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/port/{port}/in-use", code: 200 })),
+).annotate({
+  identifier: "IsPortInUseRequest",
+}) as any as S.Schema<IsPortInUseRequest>;
+
+export interface IsPortInUseResponse {
+  isInUse?: boolean;
+}
+export const IsPortInUseResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    isInUse: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "IsPortInUseResponse",
+}) as any as S.Schema<IsPortInUseResponse>;
+
+export type GetPortsError = DaytonaOpError;
+/** Get active ports Get a list of all currently active ports */
+export const getPorts: API.OperationMethod<
+  GetPortsRequest,
+  PortList,
+  GetPortsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetPortsRequest,
+  output: PortList,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IsPortInUseError = DaytonaOpError;
+/** Check if port is in use Check if a specific port is currently in use */
+export const isPortInUse: API.OperationMethod<
+  IsPortInUseRequest,
+  IsPortInUseResponse,
+  IsPortInUseError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IsPortInUseRequest,
+  output: IsPortInUseResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/preview.ts

@@ -0,0 +1,256 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface GetSandboxIdFromSignedPreviewUrlTokenRequest {
+  /** Signed preview URL token */
+  signedPreviewToken: string;
+  /** Port number to get sandbox ID from signed preview URL token */
+  port: number;
+}
+export const GetSandboxIdFromSignedPreviewUrlTokenRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      signedPreviewToken: S.String.pipe(T.Label()),
+      port: S.Number.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/preview/{signedPreviewToken}/{port}/sandbox-id",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "GetSandboxIdFromSignedPreviewUrlTokenRequest",
+  }) as any as S.Schema<GetSandboxIdFromSignedPreviewUrlTokenRequest>;
+
+export type GetSandboxIdFromSignedPreviewUrlTokenResponse = string;
+export const GetSandboxIdFromSignedPreviewUrlTokenResponse =
+  /*@__PURE__*/ S.suspend(() => S.String.pipe(T.RawResponseRoot())).annotate({
+    identifier: "GetSandboxIdFromSignedPreviewUrlTokenResponse",
+  }) as any as S.Schema<GetSandboxIdFromSignedPreviewUrlTokenResponse>;
+
+export interface GetSigningKeyRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+}
+export const GetSigningKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/preview/{sandboxId}/signing-key",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetSigningKeyRequest",
+}) as any as S.Schema<GetSigningKeyRequest>;
+
+export type GetSigningKeyResponse = string;
+export const GetSigningKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.String.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "GetSigningKeyResponse",
+}) as any as S.Schema<GetSigningKeyResponse>;
+
+export interface HasSandboxAccessRequest {
+  sandboxId: string;
+}
+export const HasSandboxAccessRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/preview/{sandboxId}/access", code: 200 }),
+  ),
+).annotate({
+  identifier: "HasSandboxAccessRequest",
+}) as any as S.Schema<HasSandboxAccessRequest>;
+
+export type HasSandboxAccessResponse = boolean;
+export const HasSandboxAccessResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Boolean.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "HasSandboxAccessResponse",
+}) as any as S.Schema<HasSandboxAccessResponse>;
+
+export interface IsPreviewWarningEnabledRequest {
+  /** ID of the sandbox, or a signed preview URL token (requires the port query param) */
+  sandboxId: string;
+  /** Port the signed preview URL token was issued for. Required when sandboxId is a signed token. */
+  port?: number;
+}
+export const IsPreviewWarningEnabledRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    port: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/preview/{sandboxId}/preview-warning",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IsPreviewWarningEnabledRequest",
+}) as any as S.Schema<IsPreviewWarningEnabledRequest>;
+
+export interface PreviewWarning {
+  /** Whether the preview warning page is enabled for the sandbox */
+  enabled: boolean;
+}
+export const PreviewWarning = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    enabled: S.Boolean,
+  }),
+).annotate({ identifier: "PreviewWarning" }) as any as S.Schema<PreviewWarning>;
+
+export interface IsSandboxPublicRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+}
+export const IsSandboxPublicRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/preview/{sandboxId}/public", code: 200 }),
+  ),
+).annotate({
+  identifier: "IsSandboxPublicRequest",
+}) as any as S.Schema<IsSandboxPublicRequest>;
+
+export type IsSandboxPublicResponse = boolean;
+export const IsSandboxPublicResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Boolean.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IsSandboxPublicResponse",
+}) as any as S.Schema<IsSandboxPublicResponse>;
+
+export interface IsValidAuthTokenRequest {
+  /** ID of the sandbox */
+  sandboxId: string;
+  /** Auth token of the sandbox */
+  authToken: string;
+}
+export const IsValidAuthTokenRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sandboxId: S.String.pipe(T.Label()),
+    authToken: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/preview/{sandboxId}/validate/{authToken}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "IsValidAuthTokenRequest",
+}) as any as S.Schema<IsValidAuthTokenRequest>;
+
+export type IsValidAuthTokenResponse = boolean;
+export const IsValidAuthTokenResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Boolean.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "IsValidAuthTokenResponse",
+}) as any as S.Schema<IsValidAuthTokenResponse>;
+
+export type GetSandboxIdFromSignedPreviewUrlTokenError = DaytonaOpError;
+/** Get sandbox ID from signed preview URL token */
+export const getSandboxIdFromSignedPreviewUrlToken: API.OperationMethod<
+  GetSandboxIdFromSignedPreviewUrlTokenRequest,
+  GetSandboxIdFromSignedPreviewUrlTokenResponse,
+  GetSandboxIdFromSignedPreviewUrlTokenError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSandboxIdFromSignedPreviewUrlTokenRequest,
+  output: GetSandboxIdFromSignedPreviewUrlTokenResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSigningKeyError = DaytonaOpError;
+/** Get the signing key for a sandbox */
+export const getSigningKey: API.OperationMethod<
+  GetSigningKeyRequest,
+  GetSigningKeyResponse,
+  GetSigningKeyError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSigningKeyRequest,
+  output: GetSigningKeyResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type HasSandboxAccessError = DaytonaOpError;
+/** Check if user has access to the sandbox */
+export const hasSandboxAccess: API.OperationMethod<
+  HasSandboxAccessRequest,
+  HasSandboxAccessResponse,
+  HasSandboxAccessError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: HasSandboxAccessRequest,
+  output: HasSandboxAccessResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IsPreviewWarningEnabledError = DaytonaOpError;
+/** Check if the preview warning page is enabled for the sandbox */
+export const isPreviewWarningEnabled: API.OperationMethod<
+  IsPreviewWarningEnabledRequest,
+  PreviewWarning,
+  IsPreviewWarningEnabledError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IsPreviewWarningEnabledRequest,
+  output: PreviewWarning,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IsSandboxPublicError = DaytonaOpError;
+/** Check if sandbox is public */
+export const isSandboxPublic: API.OperationMethod<
+  IsSandboxPublicRequest,
+  IsSandboxPublicResponse,
+  IsSandboxPublicError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IsSandboxPublicRequest,
+  output: IsSandboxPublicResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type IsValidAuthTokenError = DaytonaOpError;
+/** Check if sandbox auth token is valid */
+export const isValidAuthToken: API.OperationMethod<
+  IsValidAuthTokenRequest,
+  IsValidAuthTokenResponse,
+  IsValidAuthTokenError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: IsValidAuthTokenRequest,
+  output: IsValidAuthTokenResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));