@screepts/screeps-api 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,1147 @@
+import { EventEmitter } from "eventemitter3";
+
+//#region src/RawAPI.d.ts
+interface RawOpts extends URL {
+  url: string | URL;
+  path: string;
+  token: string;
+}
+declare class RawAPI extends EventEmitter<{
+  token: [token: string];
+  auth: [];
+  rateLimit: [ReturnType<typeof RawAPI.prototype.buildRateLimit>];
+  response: [Response];
+}> {
+  opts: {
+    url: string;
+    host?: string;
+    port?: string;
+    pathname?: string;
+    email?: string;
+    password?: string;
+    experimentalRetry429?: boolean;
+  } & AdditonalKeys;
+  token?: string;
+  private __authed;
+  constructor(opts?: Partial<RawOpts>);
+  readonly raw: {
+    token: string | undefined;
+    /**
+     * GET /api/version
+     */
+    version: () => Res<{
+      package: number;
+      protocol: number;
+      serverData: AtLeast<{
+        customObjectTypes: object;
+        historyChunkSize: number;
+        features: AtLeast<{
+          name: string;
+          version: number;
+        }>[];
+        shards: string[];
+      }>;
+      users: number;
+    } & Partial<{
+      currentSeason: string | undefined;
+      seasonAccessCost: string | undefined;
+      decorationConvertationCost: number | undefined;
+      decorationPixelizationCost: number | undefined;
+    }>>;
+    /**
+     * GET /api/authmod
+     */
+    authmod: () => Res<{
+      name: string;
+      version?: any;
+    }>;
+    /**
+     * Official:
+     * GET /room-history/${shard}/${room}/${tick}.json
+     * Private:
+     * GET /room-history
+     */
+    history: (room: string, tick: number, shard?: string) => Promise<{
+      /** milliseconds since the Unix epoch */timestamp: number;
+      room: string;
+      base: number;
+      ticks: {
+        [time: string]: AdditonalKeys;
+      };
+    }>;
+    servers: {
+      /**
+       * POST /api/servers/list
+       * A list of community servers
+       */
+      list: () => Res<{
+        servers: {
+          _id: string;
+          settings: {
+            host: string;
+            port: string;
+            pass: string;
+          };
+          name: string;
+          status: string;
+          likeCount: number;
+        }[];
+      }>;
+    };
+    auth: {
+      /**
+       * POST /api/auth/signin
+       */
+      signin: (email: string, password: string) => Res<{
+        token: string;
+      }>;
+      /**
+       * POST /api/auth/steam-ticket
+       */
+      steamTicket: (ticket: any, useNativeAuth?: boolean) => UndocumentedRes;
+      /**
+       * GET /api/auth/me
+       */
+      me: () => Res<Me>;
+      /**
+       * GET /api/auth/query-token
+       */
+      queryToken: (token: string) => UndocumentedRes;
+    };
+    register: {
+      /**
+       * GET /api/register/check-email
+       */
+      checkEmail: (email: string) => UndocumentedRes;
+      /**
+       * GET /api/register/check-username
+       */
+      checkUsername: (username: string) => UndocumentedRes;
+      /**
+       * POST /api/register/set-username
+       */
+      setUsername: (username: string) => UndocumentedRes;
+      /**
+       * POST /api/register/submit
+       */
+      submit: (username: string, email: string, password: string, modules: any) => UndocumentedRes;
+    };
+    userMessages: {
+      /**
+       * GET /api/user/messages/list?respondent={userId}
+       * @param respondent the long `_id` of the user, not the username
+       */
+      list: (respondent: string) => Res<{
+        messages: {
+          _id: string;
+          date: string;
+          type: string;
+          text: string;
+          unread: boolean;
+        }[];
+      }>;
+      /**
+       * GET /api/user/messages/index
+       */
+      index: () => Res<{
+        messages: {
+          _id: string;
+          message: {
+            _id: string;
+            user: string;
+            respondent: string;
+            date: string;
+            type: string;
+            text: string;
+            unread: boolean;
+          };
+        }[];
+        users: {
+          [userId: string]: {
+            _id: string;
+            username: string;
+            badge: Badge;
+          };
+        };
+      }>;
+      /**
+       * GET /api/user/messages/unread-count
+       */
+      unreadCount: () => Res<{
+        count: number;
+      }>;
+      /**
+       * POST /api/user/messages/send
+       * @param respondent the long `_id` of the user, not the username
+       */
+      send: (respondent: string, text: string) => Res<{}>;
+      /**
+       * POST /api/user/messages/mark-read
+       */
+      markRead: (id: string) => UndocumentedRes;
+    };
+    game: {
+      /**
+       * @param rooms An array of room names
+       * The return type is not mapped correctly
+       */
+      mapStats: (rooms: string[], statName: "owner0" | "claim0" | StatKey, shard?: string) => Res<{
+        stats: {
+          [roomName: string]: {
+            status: string;
+            novice: string;
+            own: {
+              user: string;
+              level: number;
+            };
+          } & { [key in StatKey]: {
+            user: string;
+            value: number;
+          }[] };
+        };
+        users: {
+          [userId: string]: {
+            _id: string;
+            username: string;
+            badge: Badge;
+          };
+        };
+      }>;
+      /**
+       * POST /api/game/gen-unique-object-name
+       */
+      genUniqueObjectName: (type: "flag" | "spawn", shard?: string) => Res<{
+        name: string;
+      }>;
+      /**
+       * POST /api/game/check-unique-object-name
+       */
+      checkUniqueObjectName: (type: string, name: string, shard?: string) => UndocumentedRes;
+      /**
+       * POST /api/game/place-spawn
+       */
+      placeSpawn: (room: string, x: number, y: number, name: string, shard?: string) => UndocumentedRes;
+      /**
+       * POST /api/game/create-flag
+       * - if the name is new, result.upserted[0]._id is the game id of the created flag
+       * - if not, this moves the flag and the response does not contain the id (but the id doesn't change)
+       * - `connection` looks like some internal MongoDB thing that is irrelevant to us
+       */
+      createFlag: (room: string, x: number, y: number, name: string, color?: FlagColor, secondaryColor?: FlagColor, shard?: string) => DbResponse;
+      /**
+       * POST/api/game/gen-unique-flag-name
+       */
+      genUniqueFlagName: (shard?: string) => UndocumentedRes;
+      /**
+       * POST /api/game/check-unique-flag-name
+       */
+      checkUniqueFlagName: (name: string, shard?: string) => UndocumentedRes;
+      /**
+       * POST /api/game/change-flag-color
+       */
+      changeFlagColor: (color?: FlagColor, secondaryColor?: FlagColor, shard?: string) => DbResponse;
+      /**
+       * POST /api/game/remove-flag
+       */
+      removeFlag: (room: string, name: string, shard?: string) => UndocumentedRes;
+      /**
+       * POST /api/game/add-object-intent
+       * [Missing parameter] _id is the game id of the object to affect (except for destroying structures), room is the name of the room it's in
+       * this method is used for a variety of actions, depending on the `name` and `intent` parameters
+       * @example remove flag: name = "remove", intent = {}
+       * @example destroy structure: _id = "room", name = "destroyStructure", intent = [ {id: <structure id>, roomName, <room name>, user: <user id>} ]
+      can destroy multiple structures at once
+        * @example suicide creep: name = "suicide", intent = {id: <creep id>}
+        * @example unclaim controller: name = "unclaim", intent = {id: <controller id>}
+      intent can be an empty object for suicide and unclaim, but the web interface sends the id in it, as described
+        * @example remove construction site: name = "remove", intent = {}
+        */
+      addObjectIntent: (room: string, name: string, intent: string, shard?: string) => DbResponse;
+      /**
+       * POST /api/game/create-construction
+       * @returns {{ ok, result: { ok, n }, ops: [ { type, room, x, y, structureType, user, progress, progressTotal, _id } ], insertedCount, insertedIds }}
+       */
+      createConstruction: (room: string, x: number, y: number, structureType: string, name: string, shard?: string) => DbInsertResponse<{
+        ops: {
+          type: string;
+          room: string;
+          x: number;
+          y: number;
+          structureType: string;
+          user: string;
+          progress: number;
+          progressTotal: number;
+          _id: string;
+        }[];
+      }>;
+      /**
+       * POST /api/game/set-notify-when-attacked
+       */
+      setNotifyWhenAttacked: (_id: string, enabled?: boolean, shard?: string) => DbResponse;
+      /**
+       * POST /api/game/create-invader
+       */
+      createInvader: (room: string, x: number, y: number, size: any, type: any, boosted?: boolean, shard?: string) => UndocumentedRes;
+      /**
+       * POST /api/game/remove-invader
+       */
+      removeInvader: (_id: string, shard?: string) => UndocumentedRes;
+      /**
+       * GET /api/game/time
+       */
+      time: (shard?: string) => Res<{
+        time: number;
+      }>;
+      /**
+       * GET /api/game/world-size
+       */
+      worldSize: (shard?: string) => UndocumentedRes;
+      /**
+       * GET /api/game/room-decorations
+       */
+      roomDecorations: (room: string, shard?: string) => UndocumentedRes;
+      /**
+       * GET /api/game/room-objects
+       */
+      roomObjects: (room: string, shard?: string) => UndocumentedRes;
+      /**
+       * GET /api/game/room-terrain
+       * terrain is a string of digits, giving the terrain left-to-right and top-to-bottom
+       * 0: plain, 1: wall, 2: swamp, 3: also wall
+       */
+      roomTerrain: (room: string, encoded?: number, shard?: string) => Res<{
+        terrain: {
+          room: string;
+          x: number;
+          y: number;
+          type: "wall" | "swamp";
+        }[];
+      }> | Res<{
+        terrain: {
+          _id: string;
+          room: string;
+          terrain: string;
+          type: "wall" | "swamp";
+        }[];
+      }>;
+      /**
+       * GET /api/game/room-status
+       * if the room is in a novice area, novice will contain the Unix timestamp of the end of the protection (otherwise it is absent)
+       */
+      roomStatus: (room: string, shard?: string) => Promise<{
+        _id: string;
+        status: "normal" | "out of borders";
+        novice?: string;
+      }>;
+      /**
+       * GET /api/game/room-overview
+       */
+      roomOverview: (room: string, interval?: number, shard?: string) => UndocumentedRes;
+      market: {
+        /**
+         * GET /api/game/market/orders-index
+         * - _id is the resource type, and there will only be one of each type.
+         * - `count` is the number of orders.
+         */
+        ordersIndex: (shard?: string) => Res<{
+          list: {
+            _id: string;
+            count: number;
+          }[];
+        }>;
+        /**
+         * GET /api/game/market/my-orders
+         * `resourceType` is one of the RESOURCE_* constants.
+         */
+        myOrders: () => Res<{
+          list: MarketOrder[];
+        }>;
+        /**
+         * GET /api/game/market/orders
+         * @param resourceType one of the RESOURCE_* constants.
+         * `resourceType` is one of the RESOURCE_* constants.
+         */
+        orders: (resourceType: string, shard?: string) => Res<{
+          list: MarketOrder[];
+        }>;
+        /**
+         * GET /api/game/market/stats
+         */
+        stats: (resourceType: string, shard?: string) => UndocumentedRes;
+      };
+      shards: {
+        /**
+         * GET /api/game/shards/info
+         */
+        info: () => Res<{
+          shards: {
+            name: string;
+            lastTicks: number[];
+            cpuLimit: number;
+            rooms: number;
+            users: number;
+            tick: number;
+          }[];
+        }>;
+      };
+    };
+    leaderboard: {
+      /**
+       * GET /api/leaderboard/list
+       */
+      list: (limit?: number, mode?: "world" | "power", offset?: number, season?: string) => Res<{
+        list: {
+          _id: string;
+          season: string;
+          user: string;
+          score: number;
+          rank: number;
+        }[];
+        count: number;
+        users: {
+          [userId: string]: User;
+        };
+      }>;
+      /**
+       * GET /api/leaderboard/find
+       * @param season An optional date in the format YYYY-MM, if not supplied all ranks in all seasons is returned.
+       * - `user` (not `_id`) is the user's _id, as returned by `me` and `user/find`
+       * - `rank` is 0-based
+       */
+      find: (username: string, mode?: string, season?: string) => Res<{
+        _id: string;
+        season: string;
+        user: string;
+        score: number;
+        rank: number;
+      }>;
+      /**
+       * GET /api/leaderboard/seasons
+       * The _id returned here is used for the season name in the other leaderboard calls
+       */
+      seasons: () => Res<{
+        seasons: {
+          _id: string;
+          name: string;
+          date: string;
+        }[];
+      }>;
+    };
+    user: {
+      /**
+       * POST /api/user/badge
+       */
+      badge: (badge: Badge) => Promise<{
+        ok?: number;
+        error?: string;
+      }>;
+      /**
+       * POST /api/user/respawn
+       */
+      respawn: () => UndocumentedRes;
+      /**
+       * POST /api/user/set-active-branch
+       */
+      setActiveBranch: (branch: string, activeName: string) => UndocumentedRes;
+      /**
+       * POST /api/user/clone-branch
+       */
+      cloneBranch: (branch: string | undefined, newName: string, defaultModules: CodeList) => UndocumentedRes;
+      /**
+       * POST /api/user/delete-branch
+       */
+      deleteBranch: (branch: string) => UndocumentedRes;
+      /**
+       * POST /api/user/notify-prefs
+       */
+      notifyPrefs: (prefs: any) => UndocumentedRes;
+      /**
+       * POST /api/user/tutorial-done
+       */
+      tutorialDone: () => UndocumentedRes;
+      /**
+       * POST /api/user/email
+       */
+      email: (email: string) => UndocumentedRes;
+      /**
+       * GET /api/user/world-start-room
+       */
+      worldStartRoom: (shard: string) => UndocumentedRes;
+      /**
+       * GET /api/user/world-status
+       * returns a world status
+       * - 'normal'
+       * - 'lost' when you loose all your spawns
+       * - 'empty' when you have respawned and not placed your spawn yet
+       */
+      worldStatus: () => Res<{
+        status: "normal" | "lost" | "empty";
+      }>;
+      /**
+       * GET /api/user/branches
+       */
+      branches: () => Res<{
+        list: {
+          _id: string;
+          branch: string;
+          activeWorld: boolean;
+          activeSim: boolean;
+        }[];
+      }>;
+      code: {
+        /**
+         * GET /api/user/code
+         * for pushing or pulling code, as documented at http://support.screeps.com/hc/en-us/articles/203022612
+         * @returns code
+         */
+        get: (branch: string) => Res<{
+          modules: CodeList;
+        }>;
+        /**
+         * POST /api/user/code
+         * for pushing or pulling code, as documented at http://support.screeps.com/hc/en-us/articles/203022612
+         */
+        set: (branch: string, modules: CodeList, _hash?: any) => UndocumentedRes;
+      };
+      decorations: {
+        /**
+         * GET /api/user/decorations/inventory
+         */
+        inventory: () => UndocumentedRes;
+        /**
+         * GET /api/user/decorations/themes
+         */
+        themes: () => UndocumentedRes;
+        /**
+         * POST /api/user/decorations/convert
+         */
+        convert: (decorations: number[]) => UndocumentedRes;
+        /**
+         * POST /api/user/decorations/pixelize
+         */
+        pixelize: (count: number, theme?: string) => UndocumentedRes;
+        /**
+         * POST /api/user/decorations/activate
+         */
+        activate: (_id: string, active: any) => UndocumentedRes;
+        /**
+         * POST /api/user/decorations/deactivate
+         */
+        deactivate: (decorations: string[]) => UndocumentedRes;
+      };
+      /**
+       * GET /api/user/respawn-prohibited-rooms
+       * - `rooms` is an array, but seems to always contain only one element
+       */
+      respawnProhibitedRooms: () => Res<{
+        rooms: string[];
+      }>;
+      memory: {
+        /**
+         * GET /api/user/memory?path={path}
+         * @param path the path may be empty or absent to retrieve all of Memory, Example: flags.Flag1
+         * @returns gz: followed by base64-encoded gzipped JSON encoding of the requested memory path
+         */
+        get: (path?: string, shard?: string) => Res<{
+          data: string;
+        }>;
+        /**
+         * POST /api/user/memory
+         * @param path the path may be empty or absent to retrieve all of Memory, Example: flags.Flag1
+         */
+        set: (path: string, value: any, shard?: string) => DbInsertResponse<{
+          ops: {
+            user: string;
+            expression: string;
+            hidden: boolean;
+          }[];
+          data: any;
+        }>;
+        segment: {
+          /**
+           * GET /api/user/memory-segment?segment=[0-99]
+           * @param segment A number from 0-99
+           */
+          get: (segment: number, shard?: string) => Res<{
+            data: string;
+          }>;
+          /**
+           * POST /api/user/memory-segment
+           * @param segment A number from 0-99
+           */
+          set: (segment: number, data: any, shard?: string) => UndocumentedRes;
+        };
+      };
+      /**
+       * GET /api/user/find?username={username}
+       */
+      find: (username: string) => Res<{
+        user: User;
+      }>;
+      /**
+       * GET /api/user/find?id={userId}
+       */
+      findById: (id: string) => Res<{
+        user: User;
+      }>;
+      /**
+       * GET /api/user/stats
+       */
+      stats: (interval: number) => UndocumentedRes;
+      /**
+       * GET /api/user/rooms
+       */
+      rooms: (id: string) => UndocumentedRes;
+      /**
+       * GET /api/user/overview?interval={interval}&statName={statName}
+       * @param statName energyControl
+       */
+      overview: (interval: number, statName: string) => UndocumentedRes;
+      /**
+       * GET /api/user/money-history
+       */
+      moneyHistory: (page?: number) => Res<{
+        page: number;
+        hasMore: boolean;
+        list: {
+          _id: string;
+          date: string;
+          tick: number;
+          user: string;
+          type: string;
+          balance: number;
+          change: number;
+          market: {
+            order: {
+              type: string;
+              resourceType: string;
+              price: number;
+              totalAmount: number;
+              roomName: string;
+            };
+          } | {
+            extendOrder: {
+              orderId: string;
+              addAmount: number;
+            };
+          } | {
+            resourceType: string;
+            roomName: string;
+            targetRoomName: string;
+            price: number;
+            npc: boolean;
+            amount: number;
+          } | {
+            changeOrderPrice: {
+              orderId: string;
+              oldPrice: number;
+              newPrice: number;
+            };
+          };
+        }[];
+      }>;
+      /**
+       * POST /api/user/console
+       */
+      console: (expression: any, shard?: string) => DbInsertResponse<{
+        ops: {
+          user: string;
+          expression: any;
+          _id: string;
+        }[];
+      }>;
+      /**
+       * GET /api/user/name
+       */
+      name: () => UndocumentedRes;
+    };
+    experimental: {
+      /**
+       * time is the current server tick
+       * _id contains the room name for each room, and lastPvpTime contains the last tick pvp occurred
+       * if neither a valid interval nor a valid start argument is provided, the result of the call is still ok, but with an empty rooms array.
+       */
+      pvp: (interval?: number) => Res<{
+        time: number;
+        rooms: {
+          _id: string;
+          lastPvpTime: number;
+        }[];
+      }>;
+      /**
+       * GET /api/experimental/nukes
+       */
+      nukes: () => Res<{
+        nukes: {
+          [shard: string]: {
+            _id: string;
+            type: "nuke";
+            room: string;
+            x: number;
+            y: number;
+            landTime: number;
+            launchRoomName: string;
+          };
+        };
+      }>;
+    };
+    warpath: {
+      /**
+       * GET /api/warpath/battles
+       */
+      battles: (interval?: number) => UndocumentedRes;
+    };
+    scoreboard: {
+      /**
+       * GET /api/scoreboard/list
+       */
+      list: (limit?: number, offset?: number) => UndocumentedRes;
+    };
+  };
+  currentSeason(): string;
+  isOfficialServer(): boolean;
+  mapToShard: <T>(res: T & {
+    list?: any;
+    rooms?: any;
+    shards?: any;
+  }) => T & {
+    list?: any;
+    rooms?: any;
+    shards?: any;
+  };
+  setServer(opts: Partial<RawOpts>): void;
+  auth(email: string, password: string, opts?: Partial<RawOpts>): Promise<{
+    token: string;
+  } & {
+    ok: number;
+  }>;
+  req(method: string, path: string, body?: any): UndocumentedRes;
+  gz(data: string): string;
+  inflate(data: string): any;
+  buildRateLimit(method: string, path: string, res: Response): {
+    method: string;
+    path: string;
+    limit: number;
+    remaining: number;
+    reset: number;
+    toReset: number;
+  };
+}
+type Res<T extends object> = Promise<T & {
+  ok: number;
+}>;
+type UndocumentedRes = Promise<any>;
+type AdditonalKeys<T = any> = Partial<Record<string, T>>;
+type AtLeast<T extends object> = T & AdditonalKeys;
+type DbResponse = Res<{
+  result: {
+    nModified: number;
+    ok: number;
+    upserted?: {
+      index: number;
+      _id: string;
+    }[];
+    n: number;
+  };
+  connection: {
+    host: string;
+    id: string;
+    port: number;
+  };
+}>;
+type DbInsertResponse<T> = Res<{
+  result: {
+    ok: number;
+    n: number;
+  };
+  insertedCount: number;
+  insertedIds: string[];
+} & T>;
+interface Badge {
+  color1: string;
+  color2: string;
+  color3: string;
+  flip: boolean;
+  param: number;
+  type: number | {
+    path1: string;
+    path2: string;
+  };
+}
+/**
+ * - Red = 1,
+ * - Purple = 2,
+ * - Blue = 3,
+ * - Cyan = 4,
+ * - Green = 5,
+ * - Yellow = 6,
+ * - Orange = 7,
+ * - Brown = 8,
+ * - Grey = 9,
+ * - White = 10
+ */
+type FlagColor = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
+type StatKey = "creepsLost" | "creepsProduced" | "energyConstruction" | "energyControl" | "energyCreeps" | "energyHarvested";
+interface MarketOrder {
+  _id: string;
+  created: string;
+  user: string;
+  active: boolean;
+  type: "buy" | "sell";
+  amount: number;
+  remainingAmount: number;
+  resourceType: string;
+  price: number;
+  totalAmount: number;
+  roomName: string;
+}
+interface Me extends User {
+  email: string;
+  cpu: number;
+  password: string;
+  notifyPrefs: {
+    sendOnline: any;
+    errorsInterval: any;
+    disabledOnMessages: any;
+    disabled: any;
+    interval: any;
+  };
+  credits: number;
+  lastChargeTime: any;
+  lastTweetTime: any;
+  github: {
+    id: any;
+    username: any;
+  };
+  twitter: {
+    username: string;
+    followers_count: number;
+  };
+}
+interface User {
+  _id: string;
+  username: string;
+  badge: Badge;
+  gcl: number;
+}
+interface BinaryModule {
+  /** base64 encoded binary data */
+  binary: string;
+}
+interface CodeList {
+  [fileName: string]: string | BinaryModule;
+}
+//#endregion
+//#region src/Socket.d.ts
+declare const DEFAULTS: {
+  reconnect: boolean;
+  resubscribe: boolean;
+  keepAlive: boolean;
+  maxRetries: number;
+  maxRetryDelay: number;
+};
+interface Message {
+  channel: string;
+  type: string;
+  id?: string;
+  data: any;
+}
+declare class Socket extends EventEmitter<{
+  connected: [];
+  disconnected: [];
+  error: [Error | (Event & {
+    error: Error;
+  })];
+  message: [Message];
+  token: [token: string];
+  auth: [Message & {
+    data: {
+      status: string;
+      token?: string;
+    };
+  }];
+  authed: [];
+  subscribe: [path: string];
+  unsubscribe: [path: string];
+} & {
+  [channel: string]: [Message];
+}> {
+  ws?: WebSocket;
+  api: ScreepsAPI;
+  opts: typeof DEFAULTS;
+  authed: boolean;
+  connected: boolean;
+  reconnecting: boolean;
+  keepAliveInter: number | NodeJS.Timeout;
+  __queue: string[];
+  __subQueue: string[];
+  __subs: Record<string, number>;
+  constructor(api: ScreepsAPI);
+  reset(): void;
+  connect(opts?: {}): Promise<unknown>;
+  reconnect(): Promise<void>;
+  disconnect(): void;
+  sleep(time: number): Promise<unknown>;
+  handleMessage(ev: MessageEvent): void;
+  gzip(bool: boolean): Promise<void>;
+  send(data: string): Promise<void>;
+  auth(token: string): Promise<void>;
+  subscribe(path: string, cb?: (...args: any[]) => void): Promise<void>;
+  unsubscribe(path: string): Promise<void>;
+}
+//#endregion
+//#region src/ConfigManager.d.ts
+/**
+ * Unified Credentials File v1.0.
+ * A standardized format for storing credentials and configuration for Screeps World related tools.
+ * @link https://github.com/screepers/screepers-standards/blob/master/SS3-Unified_Credentials_File.md
+ */
+interface UnifiedConfig {
+  servers: Partial<Record<string, ServerConfig>>;
+  configs?: Partial<Record<string, any>>;
+  [metadata: string]: any;
+}
+interface ServerConfig {
+  host: string;
+  /** override standard TCP port */
+  port?: number;
+  /** use SSL */
+  secure?: boolean;
+  /** authorization token */
+  token?: string;
+  /** is only supported on private servers */
+  username?: string;
+  /** is only supported on private servers */
+  password?: string;
+  /** additional metadata like ptr flag */
+  [metadata: string]: any;
+}
+/**
+ * Utility class for loading Unified Credentials Files from disk, environment variables, or other sources.
+ * Only platforms without filesystem access, {@link ConfigManager.setConfig}, must be used to provide the config data directly.
+ */
+declare class ConfigManager {
+  path?: string;
+  private _config;
+  /** Custom environment variables, useful for platforms without process.env */
+  env: Record<string, string | undefined>;
+  /** Custom file reading function, useful for platforms with a virtual filesystem */
+  readFile?: (path: string, options: {
+    encoding: "utf8";
+  }) => Promise<string>;
+  setConfig(data: unknown, path?: string): UnifiedConfig;
+  refresh(): Promise<void>;
+  getServers(): Promise<string[]>;
+  getConfig(): Promise<UnifiedConfig | null>;
+  loadConfig(path: string): Promise<UnifiedConfig | null>;
+}
+//#endregion
+//#region src/ScreepsAPI.d.ts
+interface RateLimit {
+  limit: number;
+  period: string;
+  remaining: number;
+  reset: number;
+  toReset: number;
+}
+declare class ScreepsAPI extends RawAPI {
+  socket: Socket;
+  appConfig: {
+    [metadata: string]: any;
+  };
+  rateLimits: {
+    global: RateLimit;
+    GET: {
+      [path: string]: RateLimit;
+    };
+    POST: {
+      [path: string]: RateLimit;
+    };
+  };
+  private _user?;
+  private _tokenInfo?;
+  static fromConfig(server?: string, config?: string | false, opts?: {}): Promise<ScreepsAPI>;
+  constructor(opts?: {});
+  getRateLimit(method: "GET" | "POST", path: string): RateLimit;
+  get rateLimitResetUrl(): string;
+  me(): Promise<(Me | User) & {
+    ok: number;
+  }>;
+  tokenInfo(): Promise<{
+    full: boolean;
+  }>;
+  userID(): Promise<string>;
+  readonly registerUser: (username: string, email: string, password: string, modules: any) => UndocumentedRes;
+  readonly history: (room: string, tick: number, shard?: string) => Promise<{
+    timestamp: number;
+    room: string;
+    base: number;
+    ticks: {
+      [time: string]: Partial<Record<string, any>>;
+    };
+  }>;
+  readonly authmod: () => Promise<{
+    name: string;
+    version?: any;
+  } & {
+    ok: number;
+  }>;
+  readonly version: () => Promise<{
+    package: number;
+    protocol: number;
+    serverData: {
+      customObjectTypes: object;
+      historyChunkSize: number;
+      features: ({
+        name: string;
+        version: number;
+      } & Partial<Record<string, any>>)[];
+      shards: string[];
+    } & Partial<Record<string, any>>;
+    users: number;
+  } & Partial<{
+    currentSeason: string | undefined;
+    seasonAccessCost: string | undefined;
+    decorationConvertationCost: number | undefined;
+    decorationPixelizationCost: number | undefined;
+  }> & {
+    ok: number;
+  }>;
+  readonly time: (shard?: string) => Promise<{
+    time: number;
+  } & {
+    ok: number;
+  }>;
+  readonly leaderboard: {
+    list: (limit?: number, mode?: "world" | "power", offset?: number, season?: string) => Promise<{
+      list: {
+        _id: string;
+        season: string;
+        user: string;
+        score: number;
+        rank: number;
+      }[];
+      count: number;
+      users: {
+        [userId: string]: User;
+      };
+    } & {
+      ok: number;
+    }>;
+    find: (username: string, mode?: string, season?: string) => Promise<{
+      _id: string;
+      season: string;
+      user: string;
+      score: number;
+      rank: number;
+    } & {
+      ok: number;
+    }>;
+    seasons: () => Promise<{
+      seasons: {
+        _id: string;
+        name: string;
+        date: string;
+      }[];
+    } & {
+      ok: number;
+    }>;
+  };
+  readonly market: {
+    ordersIndex: (shard?: string) => Promise<{
+      list: {
+        _id: string;
+        count: number;
+      }[];
+    } & {
+      ok: number;
+    }>;
+    myOrders: () => Promise<{
+      list: MarketOrder[];
+    } & {
+      ok: number;
+    }>;
+    orders: (resourceType: string, shard?: string) => Promise<{
+      list: MarketOrder[];
+    } & {
+      ok: number;
+    }>;
+    stats: (resourceType: string, shard?: string) => UndocumentedRes;
+  };
+  readonly console: (expression: any, shard?: string) => Promise<{
+    result: {
+      ok: number;
+      n: number;
+    };
+    insertedCount: number;
+    insertedIds: string[];
+  } & {
+    ops: {
+      user: string;
+      expression: any;
+      _id: string;
+    }[];
+  } & {
+    ok: number;
+  }>;
+  readonly code: {
+    get: (branch: string) => Promise<{
+      modules: CodeList;
+    } & {
+      ok: number;
+    }>; /** Unlike raw.code.set, this method will create a new branch if it doesn't exist */
+    set: (branch: string, code: CodeList) => UndocumentedRes;
+    branches: () => Promise<{
+      list: {
+        _id: string;
+        branch: string;
+        activeWorld: boolean;
+        activeSim: boolean;
+      }[];
+    } & {
+      ok: number;
+    }>;
+    cloneBranch: (branch: string | undefined, newName: string, defaultModules: CodeList) => UndocumentedRes;
+    deleteBranch: (branch: string) => UndocumentedRes;
+    setActiveBranch: (branch: string, activeName: string) => UndocumentedRes;
+  };
+  readonly memory: {
+    /** Unlike raw.user.memory.get, this method returns uncompressed memory */get: (path?: string, shard?: string) => Promise<string>;
+    set: (path: string, value: any, shard?: string) => Promise<{
+      result: {
+        ok: number;
+        n: number;
+      };
+      insertedCount: number;
+      insertedIds: string[];
+    } & {
+      ops: {
+        user: string;
+        expression: string;
+        hidden: boolean;
+      }[];
+      data: any;
+    } & {
+      ok: number;
+    }>;
+    segment: {
+      get: (segment: number, shard?: string) => Promise<{
+        data: string;
+      } & {
+        ok: number;
+      }>;
+      set: (segment: number, data: any, shard?: string) => UndocumentedRes;
+    };
+  };
+  readonly segment: {
+    get: (segment: number, shard?: string) => Promise<{
+      data: string;
+    } & {
+      ok: number;
+    }>;
+    set: (segment: number, data: any, shard?: string) => UndocumentedRes;
+  };
+}
+//#endregion
+export { type Badge, type CodeList, ConfigManager, type MarketOrder, type Me, ScreepsAPI, type UndocumentedRes, type User };
+//# sourceMappingURL=index.d.mts.map