@to11ai/sdk 0.0.2 → 0.1.1

package/dist/errors.cjs

@@ -44,7 +44,12 @@ __export(exports_errors, {
   To11aiNetworkError: () => To11aiNetworkError,
   To11aiError: () => To11aiError,
   To11aiAuthError: () => To11aiAuthError,
-  To11aiApiError: () => To11aiApiError
+  To11aiApiError: () => To11aiApiError,
+  RuleVersionInvalidSnapshotError: () => RuleVersionInvalidSnapshotError,
+  RuleNotFoundError: () => RuleNotFoundError,
+  PromptLabelNotRegisteredError: () => PromptLabelNotRegisteredError,
+  NoApplicableRouteError: () => NoApplicableRouteError,
+  EnvNotEnabledForProviderError: () => EnvNotEnabledForProviderError
 });
 module.exports = __toCommonJS(exports_errors);
 
@@ -103,3 +108,86 @@ class To11aiNetworkError extends To11aiError {
     Object.setPrototypeOf(this, new.target.prototype);
   }
 }
+
+class PromptLabelNotRegisteredError extends To11aiApiError {
+  projectId;
+  label;
+  constructor(message, projectId, label, details) {
+    super(message, 422, "PROMPT_LABEL_NOT_REGISTERED", details !== undefined ? details : { projectId, label });
+    this.name = "PromptLabelNotRegisteredError";
+    this.projectId = projectId;
+    this.label = label;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static is(err) {
+    return err instanceof PromptLabelNotRegisteredError;
+  }
+}
+
+class RuleNotFoundError extends To11aiApiError {
+  ruleId;
+  model;
+  env;
+  constructor(message, errorCode, fields, details) {
+    super(message, 404, errorCode, details);
+    this.name = "RuleNotFoundError";
+    this.ruleId = fields.ruleId;
+    this.model = fields.model;
+    this.env = fields.env;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static is(err) {
+    return err instanceof RuleNotFoundError;
+  }
+}
+
+class NoApplicableRouteError extends To11aiApiError {
+  ruleId;
+  versionId;
+  reason;
+  constructor(message, fields, details) {
+    super(message, 422, "NO_APPLICABLE_ROUTE", details);
+    this.name = "NoApplicableRouteError";
+    this.ruleId = fields.ruleId;
+    this.versionId = fields.versionId;
+    this.reason = fields.reason;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static is(err) {
+    return err instanceof NoApplicableRouteError;
+  }
+}
+
+class EnvNotEnabledForProviderError extends To11aiApiError {
+  ruleId;
+  envSlug;
+  providerId;
+  constructor(message, fields, details) {
+    super(message, 422, "ENV_NOT_ENABLED_FOR_PROVIDER", details);
+    this.name = "EnvNotEnabledForProviderError";
+    this.ruleId = fields.ruleId;
+    this.envSlug = fields.envSlug;
+    this.providerId = fields.providerId;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static is(err) {
+    return err instanceof EnvNotEnabledForProviderError;
+  }
+}
+
+class RuleVersionInvalidSnapshotError extends To11aiApiError {
+  field;
+  reason;
+  variantName;
+  constructor(message, errorCode, fields, details, statusCode = 400) {
+    super(message, statusCode, errorCode, details);
+    this.name = "RuleVersionInvalidSnapshotError";
+    this.field = fields.field;
+    this.reason = fields.reason;
+    this.variantName = fields.variantName;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static is(err) {
+    return err instanceof RuleVersionInvalidSnapshotError;
+  }
+}

package/dist/errors.d.ts

@@ -38,3 +38,99 @@ export declare class To11aiRateLimitError extends To11aiApiError {
 export declare class To11aiNetworkError extends To11aiError {
     constructor(message: string, cause?: unknown);
 }
+/**
+ * Thrown when strict-mode rejects a label move for an unregistered label.
+ *
+ * The API returns 422 with `error.code === "PROMPT_LABEL_NOT_REGISTERED"`
+ * when `project.enforce_label_registry = true` and the caller tries to
+ * move a label that has no active entry in the project label registry.
+ * The transport surfaces these as this typed subclass; existing
+ * `instanceof To11aiApiError` blocks still match.
+ *
+ * Note: this extends `To11aiApiError` directly (not `To11aiValidationError`,
+ * which hardcodes status 400). The API returns 422 for this case.
+ */
+export declare class PromptLabelNotRegisteredError extends To11aiApiError {
+    readonly projectId: string;
+    readonly label: string;
+    constructor(message: string, projectId: string, label: string, details?: unknown);
+    /** Type guard helper — checks `instanceof` (not parent + errorCode string). */
+    static is(err: unknown): err is PromptLabelNotRegisteredError;
+}
+/**
+ * Thrown when a rule cannot be located. Covers two variants of the same
+ * named class (single class so existing `catch (err: RuleNotFoundError)`
+ * blocks match both):
+ *
+ *   * Control-plane variant (404 `RULE_NOT_FOUND`) — `ruleId` is the id
+ *     the caller supplied and that did not exist in the project.
+ *   * Gateway variant (404 `RULE_NOT_FOUND_IN_ENV`) — `model` is the
+ *     `function::<alias>` (or raw model id) the gateway tried to resolve
+ *     and `env` is the request env. `ruleId` is undefined because the
+ *     alias may not resolve to any rule in the env.
+ */
+export declare class RuleNotFoundError extends To11aiApiError {
+    readonly ruleId: string | undefined;
+    readonly model: string | undefined;
+    readonly env: string | undefined;
+    constructor(message: string, errorCode: string, fields: {
+        ruleId?: string;
+        model?: string;
+        env?: string;
+    }, details?: unknown);
+    static is(err: unknown): err is RuleNotFoundError;
+}
+export type NoApplicableRouteReason = "all_conditions_false" | "all_variants_unreachable" | "all_steps_non_routable";
+/**
+ * Thrown when the gateway resolved a rule + version but no variant /
+ * step / chain element was applicable to the request — every condition
+ * was false, every variant unreachable, or every fallback step
+ * non-routable. Surfaces as 422 `NO_APPLICABLE_ROUTE`.
+ */
+export declare class NoApplicableRouteError extends To11aiApiError {
+    readonly ruleId: string;
+    readonly versionId: string;
+    readonly reason: NoApplicableRouteReason | string;
+    constructor(message: string, fields: {
+        ruleId: string;
+        versionId: string;
+        reason: string;
+    }, details?: unknown);
+    static is(err: unknown): err is NoApplicableRouteError;
+}
+/**
+ * Thrown when a rule references a provider that has no activation in the
+ * requested env. Surfaces as 422 `ENV_NOT_ENABLED_FOR_PROVIDER`.
+ */
+export declare class EnvNotEnabledForProviderError extends To11aiApiError {
+    readonly ruleId: string;
+    readonly envSlug: string;
+    readonly providerId: string;
+    constructor(message: string, fields: {
+        ruleId: string;
+        envSlug: string;
+        providerId: string;
+    }, details?: unknown);
+    static is(err: unknown): err is EnvNotEnabledForProviderError;
+}
+/**
+ * Thrown when version create rejects the snapshot for a structural
+ * reason — invalid variant params, malformed `when` clause, illegal
+ * weight set, malformed retry policy, … Surfaces with one of the
+ * `INVALID_VARIANT_PARAMS` / `INVALID_VARIANT_WEIGHTS` /
+ * `INVALID_RULE_STRATEGY` / `INVALID_STEP_COUNT` /
+ * `RULE_ENDPOINT_MISMATCH` / `INVALID_WHEN_CLAUSE` /
+ * `INVALID_STRATEGY_VARIANTS` / `INVALID_RETRY_POLICY` error codes
+ * at HTTP status 400 or 422.
+ */
+export declare class RuleVersionInvalidSnapshotError extends To11aiApiError {
+    readonly field: string | undefined;
+    readonly reason: string | undefined;
+    readonly variantName: string | undefined;
+    constructor(message: string, errorCode: string, fields: {
+        field?: string;
+        reason?: string;
+        variantName?: string;
+    }, details?: unknown, statusCode?: number);
+    static is(err: unknown): err is RuleVersionInvalidSnapshotError;
+}

package/dist/errors.js

@@ -54,11 +54,99 @@ class To11aiNetworkError extends To11aiError {
     Object.setPrototypeOf(this, new.target.prototype);
   }
 }
+
+class PromptLabelNotRegisteredError extends To11aiApiError {
+  projectId;
+  label;
+  constructor(message, projectId, label, details) {
+    super(message, 422, "PROMPT_LABEL_NOT_REGISTERED", details !== undefined ? details : { projectId, label });
+    this.name = "PromptLabelNotRegisteredError";
+    this.projectId = projectId;
+    this.label = label;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static is(err) {
+    return err instanceof PromptLabelNotRegisteredError;
+  }
+}
+
+class RuleNotFoundError extends To11aiApiError {
+  ruleId;
+  model;
+  env;
+  constructor(message, errorCode, fields, details) {
+    super(message, 404, errorCode, details);
+    this.name = "RuleNotFoundError";
+    this.ruleId = fields.ruleId;
+    this.model = fields.model;
+    this.env = fields.env;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static is(err) {
+    return err instanceof RuleNotFoundError;
+  }
+}
+
+class NoApplicableRouteError extends To11aiApiError {
+  ruleId;
+  versionId;
+  reason;
+  constructor(message, fields, details) {
+    super(message, 422, "NO_APPLICABLE_ROUTE", details);
+    this.name = "NoApplicableRouteError";
+    this.ruleId = fields.ruleId;
+    this.versionId = fields.versionId;
+    this.reason = fields.reason;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static is(err) {
+    return err instanceof NoApplicableRouteError;
+  }
+}
+
+class EnvNotEnabledForProviderError extends To11aiApiError {
+  ruleId;
+  envSlug;
+  providerId;
+  constructor(message, fields, details) {
+    super(message, 422, "ENV_NOT_ENABLED_FOR_PROVIDER", details);
+    this.name = "EnvNotEnabledForProviderError";
+    this.ruleId = fields.ruleId;
+    this.envSlug = fields.envSlug;
+    this.providerId = fields.providerId;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static is(err) {
+    return err instanceof EnvNotEnabledForProviderError;
+  }
+}
+
+class RuleVersionInvalidSnapshotError extends To11aiApiError {
+  field;
+  reason;
+  variantName;
+  constructor(message, errorCode, fields, details, statusCode = 400) {
+    super(message, statusCode, errorCode, details);
+    this.name = "RuleVersionInvalidSnapshotError";
+    this.field = fields.field;
+    this.reason = fields.reason;
+    this.variantName = fields.variantName;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  static is(err) {
+    return err instanceof RuleVersionInvalidSnapshotError;
+  }
+}
 export {
   To11aiValidationError,
   To11aiRateLimitError,
   To11aiNetworkError,
   To11aiError,
   To11aiAuthError,
-  To11aiApiError
+  To11aiApiError,
+  RuleVersionInvalidSnapshotError,
+  RuleNotFoundError,
+  PromptLabelNotRegisteredError,
+  NoApplicableRouteError,
+  EnvNotEnabledForProviderError
 };

package/dist/gateway.cjs

@@ -50,10 +50,17 @@ function gatewayAuthHeaders(options) {
   if (options.projectId.trim().length === 0) {
     throw new Error("[to11ai/sdk] `projectId` must not be empty.");
   }
-  return {
+  const headers = {
     "x-to11-authorization": `Bearer ${options.apiKey}`,
     "x-to11-project-id": options.projectId
   };
+  if (options.env !== undefined) {
+    if (options.env.trim().length === 0) {
+      throw new Error("[to11ai/sdk] `env` must not be empty — omit the field to use the project's gateway-fallback environment.");
+    }
+    headers["x-to11-env"] = options.env;
+  }
+  return headers;
 }
 function gatewayPromptHeaders(prompt) {
   const headers = {

package/dist/gateway.d.ts

@@ -2,12 +2,31 @@ import type { ResolvedPrompt } from "./prompts/types";
 export interface GatewayAuthOptions {
     apiKey: string;
     projectId: string;
+    /**
+     * Optional environment slug routed via the gateway's `x-to11-env`
+     * header. When omitted, the gateway falls back to the project's
+     * `is_gateway_fallback=true` environment; if no fallback exists, the
+     * request fails with `400 missing_env_no_project_default`.
+     *
+     * Slug validation matches the project-environments registry:
+     * lowercase-kebab (`a-z`, `0-9`, `-`, 1..63 chars). The SDK rejects
+     * empty / whitespace-only values eagerly so misconfiguration surfaces
+     * before the request hits the wire.
+     */
+    env?: string;
 }
 /**
  * Build the auth headers required for every request through the to11 gateway.
  *
+ * Includes `x-to11-env: <slug>` when `options.env` is set — see the
+ * environments-registry spec for gateway routing semantics. Empty /
+ * whitespace-only env values throw immediately so caller misconfiguration
+ * is loud.
+ *
  * @example
  * const headers = gatewayAuthHeaders({ apiKey, projectId });
+ * @example
+ * const headers = gatewayAuthHeaders({ apiKey, projectId, env: "staging" });
  */
 export declare function gatewayAuthHeaders(options: GatewayAuthOptions): Record<string, string>;
 /**

package/dist/gateway.js

@@ -6,10 +6,17 @@ function gatewayAuthHeaders(options) {
   if (options.projectId.trim().length === 0) {
     throw new Error("[to11ai/sdk] `projectId` must not be empty.");
   }
-  return {
+  const headers = {
     "x-to11-authorization": `Bearer ${options.apiKey}`,
     "x-to11-project-id": options.projectId
   };
+  if (options.env !== undefined) {
+    if (options.env.trim().length === 0) {
+      throw new Error("[to11ai/sdk] `env` must not be empty — omit the field to use the project's gateway-fallback environment.");
+    }
+    headers["x-to11-env"] = options.env;
+  }
+  return headers;
 }
 function gatewayPromptHeaders(prompt) {
   const headers = {

package/dist/projectEnvironments/resource.cjs

@@ -0,0 +1,110 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/projectEnvironments/resource.ts
+var exports_resource = {};
+__export(exports_resource, {
+  ProjectEnvironmentResource: () => ProjectEnvironmentResource
+});
+module.exports = __toCommonJS(exports_resource);
+function unwrap(envelope) {
+  if (envelope.data === null || envelope.data === undefined) {
+    throw new Error("API returned success but data is null");
+  }
+  return envelope.data;
+}
+function projectEnvironmentsPath(projectId) {
+  return `/v1/projects/${encodeURIComponent(projectId)}/environments`;
+}
+function projectEnvironmentPath(projectId, slug) {
+  return `${projectEnvironmentsPath(projectId)}/${encodeURIComponent(slug)}`;
+}
+
+class ProjectEnvironmentResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(input) {
+    const envelope = await this.transport.request("GET", projectEnvironmentsPath(input.projectId), {
+      query: input.includeArchived ? { includeArchived: "true" } : undefined
+    });
+    return unwrap(envelope);
+  }
+  async get(input) {
+    const envelope = await this.transport.request("GET", projectEnvironmentPath(input.projectId, input.slug));
+    return unwrap(envelope);
+  }
+  async create(input) {
+    const { projectId, ...body } = input;
+    const envelope = await this.transport.request("POST", projectEnvironmentsPath(projectId), { body });
+    return unwrap(envelope);
+  }
+  async update(input) {
+    const { projectId, slug, newSlug, ...rest } = input;
+    const body = {};
+    if (newSlug !== undefined)
+      body.slug = newSlug;
+    if (rest.name !== undefined)
+      body.name = rest.name;
+    if (rest.color !== undefined)
+      body.color = rest.color;
+    if (rest.description !== undefined)
+      body.description = rest.description;
+    if (rest.isPointer !== undefined)
+      body.isPointer = rest.isPointer;
+    if (rest.requiresApproval !== undefined)
+      body.requiresApproval = rest.requiresApproval;
+    if (rest.isDefault !== undefined)
+      body.isDefault = rest.isDefault;
+    if (rest.isGatewayFallback !== undefined)
+      body.isGatewayFallback = rest.isGatewayFallback;
+    if (rest.sortOrder !== undefined)
+      body.sortOrder = rest.sortOrder;
+    const envelope = await this.transport.request("PATCH", projectEnvironmentPath(projectId, slug), { body });
+    return unwrap(envelope);
+  }
+  async archive(input) {
+    const envelope = await this.transport.request("POST", `${projectEnvironmentPath(input.projectId, input.slug)}/archive`);
+    return unwrap(envelope);
+  }
+  async restore(input) {
+    const envelope = await this.transport.request("POST", `${projectEnvironmentPath(input.projectId, input.slug)}/restore`);
+    return unwrap(envelope);
+  }
+}

package/dist/projectEnvironments/resource.d.ts

@@ -0,0 +1,67 @@
+import type { Transport } from "../transport";
+import type { ArchiveProjectEnvironmentInput, ArchiveProjectEnvironmentResult, CreateProjectEnvironmentInput, CreateProjectEnvironmentResult, GetProjectEnvironmentInput, GetProjectEnvironmentResult, ListProjectEnvironmentsInput, ListProjectEnvironmentsResult, RestoreProjectEnvironmentInput, RestoreProjectEnvironmentResult, UpdateProjectEnvironmentInput, UpdateProjectEnvironmentResult } from "./types";
+export type { ArchiveProjectEnvironmentInput, ArchiveProjectEnvironmentResult, CreateProjectEnvironmentInput, CreateProjectEnvironmentResult, GetProjectEnvironmentInput, GetProjectEnvironmentResult, ListProjectEnvironmentsInput, ListProjectEnvironmentsResult, LivePointerCounts, ProjectEnvironment, RestoreProjectEnvironmentInput, RestoreProjectEnvironmentResult, UpdateProjectEnvironmentInput, UpdateProjectEnvironmentResult, } from "./types";
+/**
+ * SDK resource for `/v1/projects/:projectId/environments`. Constructed by
+ * `createClient` and exposed as `client.projectEnvironments`.
+ */
+export declare class ProjectEnvironmentResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * List the project's environments. Excludes archived rows by default —
+     * pass `includeArchived: true` to include rows with a non-null
+     * `archivedAt` (used by the admin / restore UI).
+     */
+    list(input: ListProjectEnvironmentsInput): Promise<ListProjectEnvironmentsResult>;
+    get(input: GetProjectEnvironmentInput): Promise<GetProjectEnvironmentResult>;
+    /**
+     * Create a new environment.
+     *
+     * `slug` must match lowercase-kebab (`a-z`, `0-9`, `-`, 1..63 chars).
+     * Reserved system slugs (`prod`, `staging`) and any already-used slug
+     * return 409 `ENVIRONMENT_SLUG_TAKEN`.
+     *
+     * Setting `isGatewayFallback: true` additionally requires the
+     * `project:manage_default_environment` capability; the create use
+     * case clears the flag on any other env in the same project.
+     */
+    create(input: CreateProjectEnvironmentInput): Promise<CreateProjectEnvironmentResult>;
+    /**
+     * PATCH an environment.
+     *
+     * - System envs (`isSystem: true`) reject `slug`/`isSystem`/immutable-
+     *   field mutations with 409 `SYSTEM_ENV_IMMUTABLE`.
+     * - Renaming via `newSlug` triggers a 7-day alias row server-side so
+     *   in-flight gateway requests carrying the old slug keep resolving.
+     * - Mutating `isGatewayFallback` requires the
+     *   `project:manage_default_environment` capability AND the target
+     *   env must have at least one live snapshot (else 409
+     *   `FALLBACK_ENV_NOT_READY`).
+     *
+     * The SDK marshals `newSlug` onto the wire as `slug` (the API accepts
+     * `slug` on the PATCH body for a rename — the URL slug stays the
+     * pre-rename identifier).
+     */
+    update(input: UpdateProjectEnvironmentInput): Promise<UpdateProjectEnvironmentResult>;
+    /**
+     * Soft-archive an environment. The response carries the archived row
+     * plus a `livePointerCounts` summary (informational — pointers are
+     * cascade-cleared by the use case).
+     *
+     * System envs (`isSystem: true`) and the current gateway-fallback env
+     * cannot be archived; the API returns 409 `SYSTEM_ENV_IMMUTABLE` or
+     * `CANNOT_ARCHIVE_GATEWAY_FALLBACK` respectively.
+     *
+     * Uses `POST /:slug/archive` rather than `DELETE` so the server can
+     * return a structured 200 with the archived row + counts.
+     */
+    archive(input: ArchiveProjectEnvironmentInput): Promise<ArchiveProjectEnvironmentResult>;
+    /**
+     * Restore a previously-archived environment. The server resets
+     * `archivedAt` to `null` and returns the live row. No-op if the env
+     * is already live; returns 404 `ENVIRONMENT_NOT_FOUND` if the slug
+     * has never existed.
+     */
+    restore(input: RestoreProjectEnvironmentInput): Promise<RestoreProjectEnvironmentResult>;
+}

package/dist/projectEnvironments/resource.js

@@ -0,0 +1,70 @@
+// src/projectEnvironments/resource.ts
+function unwrap(envelope) {
+  if (envelope.data === null || envelope.data === undefined) {
+    throw new Error("API returned success but data is null");
+  }
+  return envelope.data;
+}
+function projectEnvironmentsPath(projectId) {
+  return `/v1/projects/${encodeURIComponent(projectId)}/environments`;
+}
+function projectEnvironmentPath(projectId, slug) {
+  return `${projectEnvironmentsPath(projectId)}/${encodeURIComponent(slug)}`;
+}
+
+class ProjectEnvironmentResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(input) {
+    const envelope = await this.transport.request("GET", projectEnvironmentsPath(input.projectId), {
+      query: input.includeArchived ? { includeArchived: "true" } : undefined
+    });
+    return unwrap(envelope);
+  }
+  async get(input) {
+    const envelope = await this.transport.request("GET", projectEnvironmentPath(input.projectId, input.slug));
+    return unwrap(envelope);
+  }
+  async create(input) {
+    const { projectId, ...body } = input;
+    const envelope = await this.transport.request("POST", projectEnvironmentsPath(projectId), { body });
+    return unwrap(envelope);
+  }
+  async update(input) {
+    const { projectId, slug, newSlug, ...rest } = input;
+    const body = {};
+    if (newSlug !== undefined)
+      body.slug = newSlug;
+    if (rest.name !== undefined)
+      body.name = rest.name;
+    if (rest.color !== undefined)
+      body.color = rest.color;
+    if (rest.description !== undefined)
+      body.description = rest.description;
+    if (rest.isPointer !== undefined)
+      body.isPointer = rest.isPointer;
+    if (rest.requiresApproval !== undefined)
+      body.requiresApproval = rest.requiresApproval;
+    if (rest.isDefault !== undefined)
+      body.isDefault = rest.isDefault;
+    if (rest.isGatewayFallback !== undefined)
+      body.isGatewayFallback = rest.isGatewayFallback;
+    if (rest.sortOrder !== undefined)
+      body.sortOrder = rest.sortOrder;
+    const envelope = await this.transport.request("PATCH", projectEnvironmentPath(projectId, slug), { body });
+    return unwrap(envelope);
+  }
+  async archive(input) {
+    const envelope = await this.transport.request("POST", `${projectEnvironmentPath(input.projectId, input.slug)}/archive`);
+    return unwrap(envelope);
+  }
+  async restore(input) {
+    const envelope = await this.transport.request("POST", `${projectEnvironmentPath(input.projectId, input.slug)}/restore`);
+    return unwrap(envelope);
+  }
+}
+export {
+  ProjectEnvironmentResource
+};