@crowdedkingdoms/crowdyjs 18.0.3-dev.1 → 18.1.0-dev.1

package/dist/domains/gameApps.js

@@ -1,4 +1,4 @@
-import { GridOwnershipDocument, AssignGridOwnershipDocument, TransferGridOwnershipDocument, GridUserPermissionsDocument, NearbyGridPermissionsDocument, NearbyGridsDocument, GridPermissionLimitsDocument, GridGroupGrantsDocument, CreateGridDocument, DeleteGridDocument, GrantGridPermissionsDocument, RevokeGridPermissionsDocument, SetGridPermissionLimitsDocument, AssignGroupToGridDocument, RevokeGroupFromGridDocument, } from '../generated/graphql.js';
+import { GridOwnershipDocument, AssignGridOwnershipDocument, TransferGridOwnershipDocument, GridUserPermissionsDocument, NearbyGridPermissionsDocument, NearbyGridsDocument, GridPermissionLimitsDocument, GridOpenPermissionsDocument, GridGroupGrantsDocument, CreateGridDocument, DeleteGridDocument, GrantGridPermissionsDocument, RevokeGridPermissionsDocument, SetGridPermissionLimitsDocument, SetGridOpenPermissionsDocument, AssignGroupToGridDocument, RevokeGroupFromGridDocument, } from '../generated/graphql.js';
 /**
  * App grids + grid runtime-permission administration — exposed as
  * `client.gameApps` (and grouped under `client.admin`).
@@ -98,6 +98,21 @@ export class GameAppsAPI {
         });
         return data.gridPermissionLimits;
     }
+    /**
+     * Read the keys a grid grants every player with active access to the app
+     * (an open build area, a public arena). Empty means the grid is not open.
+     *
+     * @param appId - App that owns the grid.
+     * @param gridId - Grid whose open keys to read.
+     * @returns The grid's open keys.
+     */
+    async openPermissions(appId, gridId) {
+        const data = await this.graphql.request(GridOpenPermissionsDocument, {
+            appId,
+            gridId,
+        });
+        return data.gridOpenPermissions;
+    }
     /**
      * List a group's grants on a grid (rows of the group-grants input table).
      *
@@ -180,6 +195,27 @@ export class GameAppsAPI {
         });
         return data.setGridPermissionLimits;
     }
+    /**
+     * Open a grid to every player: replace the keys it grants each player with
+     * active access to the app, within its limits, then recompute the effective
+     * ACL for all of them. Players who gain access later get them too. The most
+     * specific grid covering a chunk decides a voxel write there, so a zone
+     * nested in the world grid that everyone may build in must grant
+     * `update_voxel_data` itself. An empty `permissionKeys` closes the grid.
+     *
+     * Refused with `BAD_REQUEST` for the app's world grid (open already), any of
+     * the four player-code keys, a key that is not an active grid key, and a
+     * 33rd open grid in one app.
+     *
+     * @param input - {@link SetGridOpenPermissionsInput}.
+     * @returns The grid's open keys after the change.
+     */
+    async setOpenPermissions(input) {
+        const data = await this.graphql.request(SetGridOpenPermissionsDocument, {
+            input,
+        });
+        return data.setGridOpenPermissions;
+    }
     /**
      * Grant permission keys to a group (optionally a single role) on a grid;
      * recomputes the effective ACL.

package/dist/generated/graphql.d.ts

@@ -916,6 +916,8 @@ export type App = {
     updatedAt: Scalars['DateTime']['output'];
     /** Marketplace discoverability (PUBLIC/UNLISTED/PRIVATE). See AppVisibility. */
     visibility: AppVisibility;
+    /** Whether players may write the app's wilderness: chunks that no grid but the app's world grid covers. True (the default) leaves those writes to the ordinary voxel permission; false refuses every voxel and chunk write there (updateVoxel, sendVoxelUpdate, updateChunk, ck-exec's world.set_voxels, and a client's voxel updates sent straight to the realtime servers), whoever makes it. Set with updateApp (manage_apps). */
+    wildernessWritesOpen: Scalars['Boolean']['output'];
 };
 /** A free or purchasable access tier for an app, bundling a price and the set of runtime permission keys that granted users receive. */
 export type AppAccessTier = {
@@ -3997,6 +3999,16 @@ export type GridGroupGrant = {
     /** The runtime permission key string granted to the group/role. */
     permissionKey: Scalars['String']['output'];
 };
+/** The permission keys a grid grants every player with active access to the app (the grid_open_permissions input table). */
+export type GridOpenPermissions = {
+    __typename?: 'GridOpenPermissions';
+    /** The app (tenant) that owns the grid. */
+    appId: Scalars['BigInt']['output'];
+    /** The grid. */
+    gridId: Scalars['BigInt']['output'];
+    /** The keys every player with active access holds on this grid (its limits still cap them). Empty means the grid is not open. */
+    permissionKeys: Array<Scalars['String']['output']>;
+};
 /** Kind of principal holding grid title. P1 can assign USER owners; GROUP and ORG are schema-reserved for future shared ownership. */
 export declare enum GridOwnerKind {
     Group = "GROUP",
@@ -4343,7 +4355,7 @@ export type Mutation = {
     claimFreeAppAccess: AppUserAccess;
     /** Claim the hosting slug for an app (idempotent; the same app re-claiming its slug is a no-op, a different slug MOVES the game). Registers https://<games host>/<slug>/ and https://<slug>.<content host> as the app's redirect URIs and sets launch_url to the former. Requires manage_apps on the app and a SESSION token. Refuses a slug that is not a DNS label, is reserved, or belongs to another app (HOSTED_SLUG_UNAVAILABLE), and answers CONTENT_HOSTING_DISABLED on a tier without a content CDN. */
     claimGameHosting: HostedGame;
-    /** Claim one currently unclaimed chunk as a new player-owned grid. Requires an ordinary app-scoped player token and active app access, but never manage_apps. The app's policy must be SELF_CLAIM. The server validates the app's grid assignment and peer-overlap rules, then atomically creates a one-chunk grid, assigns current-user ownership, grants access/update_voxel_data/use_voice_chat/teleport plus the player-code keys and use_video_chat where the caller's tier already carries them, and materializes the effective ACL. Conflicts and policy denials throw GraphQL errors; no partial grid, ownership, or grant rows remain. */
+    /** Claim one wilderness chunk (a chunk no grid but the app's world grid covers) as a new player-owned grid. Requires an ordinary app-scoped player token and active app access, but never manage_apps. The app's policy must be SELF_CLAIM. A chunk inside another grid (a plot, a zone or another claim) is refused FORBIDDEN (GRID_NOT_CLAIMABLE): the claim would be the most specific grid there and take the chunk from whoever that grid grants. The server validates the app's grid assignment and peer-overlap rules, then atomically creates a one-chunk grid, assigns current-user ownership, grants access/update_voxel_data/use_voice_chat/teleport plus the player-code keys and use_video_chat where the caller's tier already carries them, and materializes the effective ACL. Conflicts and policy denials throw GraphQL errors; no partial grid, ownership, or grant rows remain. */
     claimGridChunk: ChunkClaimResult;
     /** Claim grid ownership under the app's claim policy (D4, server-authorized — no client manage_apps involved). SELF_CLAIM assigns ownership immediately; APPROVAL creates a pending request for designated approvers; INVITE requires a standing invite (consumed on use); MARKETPLACE_ONLY refuses. The grid must exist and have no current owner; game rules gate who may attempt a claim. */
     claimGridOwnership: GridClaimResult;
@@ -4601,7 +4613,7 @@ export type Mutation = {
     sendTextPacket: Scalars['Boolean']['output'];
     /** Send ONE webcam video fragment, fanned out to nearby actors as a ClientVideoNotification (Buddy v0.25.0). Requires a bearer game token and the use_video_chat runtime permission at app AND grid level -- without it the game server responds asynchronously with a GenericErrorResponse (errorCode UNAUTHORIZED). A datagram carries at most ~1117 bytes of videoData, so an encoded frame is split by the SDK into fragments (6-byte header: version, codec, frameId, fragIndex, fragCount; at most 16 per frame) and reassembled by receivers; this is a mutation PER FRAGMENT and sustained video belongs on the binary realtime relay. Every receiver in range pays the egress bytes: keep distance small and frames few. Opens a UDP proxy session automatically if none exists. Returns Boolean! that is true only when the datagram was ACCEPTED FOR SENDING -- NOT that it was delivered; the sender receives no echo, only errors (GenericErrorResponse, correlated by sequenceNumber) on udpNotifications. */
     sendVideoPacket: Scalars['Boolean']['output'];
-    /** Send a single voxel (block) update for spatial replication to nearby chunks. Requires a bearer game token; opens a UDP proxy session automatically if none exists. Returns Boolean! that is true only when the datagram was ACCEPTED FOR SENDING to the game server — NOT confirmation that the world applied the change. There is NO separate per-request success response: the change fans out to nearby clients (the sender included) as a VoxelUpdateNotification carrying the same sequenceNumber (VoxelUpdateResponse is legacy and is never emitted). Failures arrive ASYNCHRONOUSLY as a GenericErrorResponse; both are correlated by the request sequenceNumber (correlation only — not an idempotency key; the server does not dedupe replays). */
+    /** Send a single voxel (block) update for spatial replication to nearby chunks. Requires a bearer game token; opens a UDP proxy session automatically if none exists. Returns Boolean! that is true only when the datagram was ACCEPTED FOR SENDING to the game server — NOT confirmation that the world applied the change. There is NO separate per-request success response: the change fans out to nearby clients (the sender included) as a VoxelUpdateNotification carrying the same sequenceNumber (VoxelUpdateResponse is legacy and is never emitted). Failures arrive ASYNCHRONOUSLY as a GenericErrorResponse; both are correlated by the request sequenceNumber (correlation only — not an idempotency key; the server does not dedupe replays). Throws FORBIDDEN synchronously, before anything is sent, without the voxel edit permission updateVoxel checks for the chunk (app access, the tier's update_voxel_data, and update_voxel_data on the most specific grid covering the chunk), and for a chunk only the app's world grid covers while the app's wilderness is closed (App.wildernessWritesOpen false). */
     sendVoxelUpdate: Scalars['Boolean']['output'];
     /** Creates or updates an app's monthly spend cap (idempotent upsert keyed by org + app) and returns the resulting budget. This only records the cap used to monitor/limit overspend; it does not move money, charge a card, or alter the wallet balance. Requires the 'manage_billing' app permission. */
     setAppBudget: AppBudget;
@@ -4631,6 +4643,8 @@ export type Mutation = {
     setCrowdyStudioAgentPolicy: CrowdyStudioAgentPolicy;
     /** Sets the per-user early-access override flag, forcing early access on or off regardless of the global free-play window. Requires a super-admin bearer game token (and the management API enabled). */
     setEarlyAccessOverride: User;
+    /** Open a grid to every player: replace the permission keys it grants each player with active access to the app (writes the `grid_open_permissions` input table), then recompute the grid's materialized effective ACL for all of them. The most specific grid covering a chunk decides a voxel write there, so a zone inside the world grid that everyone may build in must grant `update_voxel_data` itself. The grid's limits still cap these keys; players who get access later receive them when they connect. Pass an empty array to close the grid. Refuses the app's world grid (already open), the four player-code keys, and a 33rd open grid in one app. Requires app-admin ('manage_apps'). */
+    setGridOpenPermissions: GridOpenPermissions;
     /** Replace the whitelist of permission keys allowed on a grid (writes the `grid_permission_limits` input table), then recompute the grid's materialized effective ACL so any keys no longer on the whitelist are dropped for all users. Pass an empty array to remove all limits. Requires app-admin ('manage_apps'). DESTRUCTIVE: narrowing the whitelist can strip effective permissions from existing users on the grid. */
     setGridPermissionLimits: GridPermissionLimits;
     /** Developer switch: DISABLED (the shell says "disabled by its developer") or back to LIVE. A TAKEN_DOWN game is refused (HOSTED_GAME_TAKEN_DOWN). Requires manage_apps and a SESSION token. */
@@ -4683,7 +4697,7 @@ export type Mutation = {
     updateActor: Actor;
     /** Replaces an actor’s `publicState` and/or `privateState` blobs (fields omitted from `input` are left unchanged). OWNER-EXCLUSIVE: only the actor’s owner may write (throws Unauthorized otherwise). Game-plane: requires an app token for the actor’s app (a session token or another app’s token is answered NotFound). `uuid` is the 32-character ASCII actor id; blobs are base64-encoded binary. */
     updateActorState: Actor;
-    /** Update mutable fields of an existing app (name, description, visibility, status, metadata); only fields present in the input are changed. Requires the 'manage_apps' permission on the app (resolved via its org); super admins bypass. Use this to publish (status=LIVE), change visibility, or restore an archived app (status back to DRAFT/LIVE). Throws if the app id does not exist. */
+    /** Update mutable fields of an existing app (name, description, visibility, status, metadata, wildernessWritesOpen); only fields present in the input are changed. Requires the 'manage_apps' permission on the app (resolved via its org); super admins bypass. Use this to publish (status=LIVE), change visibility, or restore an archived app (status back to DRAFT/LIVE). Throws if the app id does not exist. */
     updateApp: App;
     /** Updates an avatar’s mutable fields (currently `name`) and returns it. OWNER-EXCLUSIVE: only the avatar’s owner may call this (throws Unauthorized otherwise). Requires a valid game token. To change state blobs use `updateAvatarState`. */
     updateAvatar: Avatar;
@@ -4695,7 +4709,7 @@ export type Mutation = {
     updateChannel: Group;
     /** Update a channel role's name, rank, and/or permission keys (system roles cannot be renamed/re-ranked). When permissions are supplied they REPLACE the role's existing keys. Requires the 'manage_roles' channel permission (app admins bypass). Note: changing send_messages here does not re-push Buddy until affected members' roles are re-applied via setChannelMemberRoles. */
     updateChannelRole: GroupRole;
-    /** Creates or replaces a chunk's dense voxel grid and/or per-voxel states for the given app and coordinates, records each provided voxel state as an individual voxel update, and asynchronously uploads the chunk to the CDN. WRITES world state. Leaves chunkState and LODs untouched. Requires a valid bearer token (app-scoped tokens are limited to their own app); no additional org/app permission is enforced on this field. */
+    /** Creates or replaces a chunk's dense voxel grid and/or per-voxel states for the given app and coordinates, records each provided voxel state as an individual voxel update, and asynchronously uploads the chunk to the CDN. WRITES world state. Leaves chunkState and LODs untouched. Requires an app token for the app and either the 'manage_apps' permission on the app (resolved via its org; super admins bypass) or the voxel edit permission for this chunk that updateVoxel checks (app access, the tier's update_voxel_data, and update_voxel_data on the most specific grid covering the chunk). Throws FORBIDDEN otherwise, and for a chunk only the app's world grid covers while the app's wilderness is closed (App.wildernessWritesOpen false). */
     updateChunk: Chunk;
     /** Replaces the level-of-detail (LOD) set for a chunk, preserving voxels, per-voxel states, chunk state and owner; returns the updated chunk (or null if it could not be written). WRITES world state. Requires a valid bearer token AND the `manage_apps` permission on the org that owns input.appId (super admins bypass). */
     updateChunkLods: Maybe<Chunk>;
@@ -4719,7 +4733,7 @@ export type Mutation = {
     updateUserState: User;
     /** Sets the target user’s account `user_type` (e.g. "direct", "deleted"). Requires a super-admin bearer game token (and the management API enabled). */
     updateUserType: User;
-    /** Records (upserts) a single voxel edit in the voxel_updates log for one chunk and returns the resulting Voxel. WRITES world state; a background maintenance job later folds these edits into the chunk's packed grid. Requires a valid bearer token AND voxel-edit permission for the target region: the user must have active app access, the `update_voxel_data` tier permission, and (when grids cover the chunk) `update_voxel_data` on a covering grid. */
+    /** Records (upserts) a single voxel edit in the voxel_updates log for one chunk and returns the resulting Voxel. WRITES world state; a background maintenance job later folds these edits into the chunk's packed grid. Requires a valid bearer token AND voxel-edit permission for the target region: the user must have active app access, the `update_voxel_data` tier permission, and `update_voxel_data` on the most specific grid covering the chunk (the smallest by volume; of equal ones the lowest grid id), so a claim, a plot or a safe zone decides its chunks and the app's world grid decides only the wilderness. A chunk no grid covers is refused, and so is a chunk only the app's world grid covers while the app's wilderness is closed (App.wildernessWritesOpen false). */
     updateVoxel: Voxel;
 };
 export type MutationAbandonGamePublishArgs = {
@@ -5285,6 +5299,9 @@ export type MutationSetEarlyAccessOverrideArgs = {
     userId: Scalars['BigInt']['input'];
     value: Scalars['Boolean']['input'];
 };
+export type MutationSetGridOpenPermissionsArgs = {
+    input: SetGridOpenPermissionsInput;
+};
 export type MutationSetGridPermissionLimitsArgs = {
     input: SetGridPermissionLimitsInput;
 };
@@ -6443,6 +6460,8 @@ export type Query = {
     gridClaimRequests: Array<GridClaimRequest>;
     /** List the group/role -> permission-key grants configured on a grid for one group (rows of the `grid_group_grants` input table). These are inputs to the effective ACL, not the materialized result — use `gridUserPermissions` for a specific user's effective keys. Requires app-admin ('manage_apps'). */
     gridGroupGrants: Array<GridGroupGrant>;
+    /** Read the permission keys a grid grants every player with active access to the app (an open build area, a public arena). An empty list means the grid is not open. Requires app-admin ('manage_apps'). */
+    gridOpenPermissions: GridOpenPermissions;
     /** Read the current first-class ownership record for a grid. Requires authentication. Returns null when the grid has no current/unexpired owner. Player server code always resolves its execution identity from this record. */
     gridOwnership: Maybe<GridOwnership>;
     /** Read the permission-key whitelist configured for a grid. An empty list means there is no limit (every active runtime permission may be granted on the grid). Requires app-admin ('manage_apps'). */
@@ -6954,6 +6973,10 @@ export type QueryGridGroupGrantsArgs = {
     gridId: Scalars['BigInt']['input'];
     groupId: Scalars['BigInt']['input'];
 };
+export type QueryGridOpenPermissionsArgs = {
+    appId: Scalars['BigInt']['input'];
+    gridId: Scalars['BigInt']['input'];
+};
 export type QueryGridOwnershipArgs = {
     appId: Scalars['BigInt']['input'];
     gridId: Scalars['BigInt']['input'];
@@ -7711,6 +7734,15 @@ export type SetCrowdyStudioProviderConsentInput = {
     /** True to accept, false to revoke. */
     consented: Scalars['Boolean']['input'];
 };
+/** Set the permission keys a grid grants every player with active access to the app (writes the grid_open_permissions input table): an open build area, a public arena. */
+export type SetGridOpenPermissionsInput = {
+    /** The app (tenant) that owns the grid. */
+    appId: Scalars['BigInt']['input'];
+    /** The grid to open (or close). Not the app's world grid, which is open by default. */
+    gridId: Scalars['BigInt']['input'];
+    /** The keys every player with active access holds on this grid, capped by its limits. Empty array closes it (players keep only what they are granted directly or through a group). Each must be an active grid permission key, unique, at most 64 chars, and not one of the four player-code keys. */
+    permissionKeys: Array<Scalars['String']['input']>;
+};
 /** Set the per-grid permission-key whitelist (writes the grid_permission_limits input table). */
 export type SetGridPermissionLimitsInput = {
     /** The app (tenant) that owns the grid. */
@@ -8056,6 +8088,8 @@ export type UpdateAppInput = {
     status?: InputMaybe<AppStatus>;
     /** New visibility (PUBLIC/UNLISTED/PRIVATE). Omit to leave unchanged. */
     visibility?: InputMaybe<AppVisibility>;
+    /** Open (true) or close (false) the app's wilderness to voxel and chunk writes: chunks that no grid but the app's world grid covers. Closing refuses every write there, whoever makes it; each game API replica, and each realtime server for a client's direct voxel updates, acts on the change within about 15 seconds. Omit to leave unchanged. */
+    wildernessWritesOpen?: InputMaybe<Scalars['Boolean']['input']>;
 };
 export type UpdateAvatarAppStateInput = {
     /** App (game) id the state is scoped to. Required. BigInt sent as a decimal string. */
@@ -8158,11 +8192,11 @@ export type UpdateVoxelInput = {
     appId: Scalars['BigInt']['input'];
     /** Address of the chunk that contains the voxel to edit. */
     coordinates: ChunkCoordinatesInput;
-    /** Local voxel position within the chunk (0-15 per axis; validated to the signed 16-bit range). */
+    /** Local voxel position within the chunk, 0-15 per axis; anything else is refused. */
     location: VoxelCoordinatesInput;
     /** Optional BASE64-encoded binary state blob for the voxel; omit for none. */
     state?: InputMaybe<Scalars['String']['input']>;
-    /** Voxel type id to write (0-255). */
+    /** Voxel type id to write, 0-255; anything else is refused. */
     voxelType: Scalars['Float']['input'];
 };
 /** One minute-bucketed usage sample. Byte/message counters are returned as strings because they can exceed the 32-bit Int range. */
@@ -8364,9 +8398,9 @@ export type VoxelState = {
 export type VoxelStateInput = {
     /** BASE64-encoded binary state blob for this voxel; omit/null for no extra state. */
     state?: InputMaybe<Scalars['String']['input']>;
-    /** Local voxel position within the chunk (0-15 per axis). */
+    /** Local voxel position within the chunk, 0-15 per axis; anything else is refused. */
     voxelCoord: VoxelCoordinatesInput;
-    /** Voxel type id to set at this position (0-255). */
+    /** Voxel type id to set at this position, 0-255; anything else is refused. */
     voxelType: Scalars['Int']['input'];
 };
 /** Relay-style cursor-paginated connection over voxel edit history entries (VoxelUpdateHistoryEvent). Page with `first`/`after`; cursors are opaque. */
@@ -8453,11 +8487,11 @@ export type VoxelUpdateRequestInput = {
     sequenceNumber?: InputMaybe<Scalars['Int']['input']>;
     /** A unique identifier for this voxel update. Must be exactly 32 bytes when encoded as UTF-8. */
     uuid: Scalars['String']['input'];
-    /** The voxel coordinates within the chunk. Values must be between -32768 and 32767 (int16 range). */
+    /** The voxel coordinates within the chunk, 0-15 on each axis; anything else is refused. */
     voxel: VoxelCoordinatesInput;
     /** Optional voxel state data, base64-encoded. Omit (or send an empty string) when the voxel has no extra state — an empty payload is a type-only update. */
     voxelState?: InputMaybe<Scalars['String']['input']>;
-    /** The new voxel type ID. This determines the appearance and properties of the voxel. */
+    /** The new voxel type ID, 0-255 (anything else is refused). This determines the appearance and properties of the voxel. */
     voxelType: Scalars['Int']['input'];
 };
 /** LEGACY — never emitted. The game server retired the dedicated voxel-update response opcode (132); an applied update now arrives as your own VoxelUpdateNotification (the sender is included in the chunk fan-out) and failures arrive as GenericErrorResponse. This type remains in the UdpNotification union for backward compatibility only — do not select it in new code; it will be removed in a future major version. */
@@ -9049,6 +9083,7 @@ export type AppQuery = {
         visibility: AppVisibility;
         status: AppStatus;
         metadata: string | null;
+        wildernessWritesOpen: boolean;
         splitMode: boolean;
         deploymentTarget: string;
         reservedUdpBytesPerSec: string;
@@ -9086,6 +9121,7 @@ export type AppBySlugQuery = {
         visibility: AppVisibility;
         status: AppStatus;
         metadata: string | null;
+        wildernessWritesOpen: boolean;
         splitMode: boolean;
         gameApiUrl: string | null;
         createdAt: string;
@@ -9126,6 +9162,7 @@ export type AppsForOrgQuery = {
         visibility: AppVisibility;
         status: AppStatus;
         metadata: string | null;
+        wildernessWritesOpen: boolean;
         splitMode: boolean;
         gameApiUrl: string | null;
         createdAt: string;
@@ -9238,6 +9275,7 @@ export type CreateAppMutation = {
         visibility: AppVisibility;
         status: AppStatus;
         metadata: string | null;
+        wildernessWritesOpen: boolean;
         createdAt: string;
     };
 };
@@ -9338,6 +9376,7 @@ export type MyAppsQuery = {
         visibility: AppVisibility;
         status: AppStatus;
         metadata: string | null;
+        wildernessWritesOpen: boolean;
         splitMode: boolean;
         gameApiUrl: string | null;
         createdAt: string;
@@ -9386,6 +9425,7 @@ export type UpdateAppMutation = {
         visibility: AppVisibility;
         status: AppStatus;
         metadata: string | null;
+        wildernessWritesOpen: boolean;
         updatedAt: string;
     };
 };
@@ -11463,6 +11503,19 @@ export type GridPermissionLimitsQuery = {
         permissionKeys: Array<string>;
     };
 };
+export type GridOpenPermissionsQueryVariables = Exact<{
+    appId: Scalars['BigInt']['input'];
+    gridId: Scalars['BigInt']['input'];
+}>;
+export type GridOpenPermissionsQuery = {
+    __typename?: 'Query';
+    gridOpenPermissions: {
+        __typename?: 'GridOpenPermissions';
+        appId: string;
+        gridId: string;
+        permissionKeys: Array<string>;
+    };
+};
 export type GridGroupGrantsQueryVariables = Exact<{
     appId: Scalars['BigInt']['input'];
     gridId: Scalars['BigInt']['input'];
@@ -11556,6 +11609,18 @@ export type SetGridPermissionLimitsMutation = {
         permissionKeys: Array<string>;
     };
 };
+export type SetGridOpenPermissionsMutationVariables = Exact<{
+    input: SetGridOpenPermissionsInput;
+}>;
+export type SetGridOpenPermissionsMutation = {
+    __typename?: 'Mutation';
+    setGridOpenPermissions: {
+        __typename?: 'GridOpenPermissions';
+        appId: string;
+        gridId: string;
+        permissionKeys: Array<string>;
+    };
+};
 export type AssignGroupToGridMutationVariables = Exact<{
     input: AssignGroupToGridInput;
 }>;
@@ -14476,12 +14541,14 @@ export declare const GridUserPermissionsDocument: DocumentNode<GridUserPermissio
 export declare const NearbyGridPermissionsDocument: DocumentNode<NearbyGridPermissionsQuery, NearbyGridPermissionsQueryVariables>;
 export declare const NearbyGridsDocument: DocumentNode<NearbyGridsQuery, NearbyGridsQueryVariables>;
 export declare const GridPermissionLimitsDocument: DocumentNode<GridPermissionLimitsQuery, GridPermissionLimitsQueryVariables>;
+export declare const GridOpenPermissionsDocument: DocumentNode<GridOpenPermissionsQuery, GridOpenPermissionsQueryVariables>;
 export declare const GridGroupGrantsDocument: DocumentNode<GridGroupGrantsQuery, GridGroupGrantsQueryVariables>;
 export declare const CreateGridDocument: DocumentNode<CreateGridMutation, CreateGridMutationVariables>;
 export declare const DeleteGridDocument: DocumentNode<DeleteGridMutation, DeleteGridMutationVariables>;
 export declare const GrantGridPermissionsDocument: DocumentNode<GrantGridPermissionsMutation, GrantGridPermissionsMutationVariables>;
 export declare const RevokeGridPermissionsDocument: DocumentNode<RevokeGridPermissionsMutation, RevokeGridPermissionsMutationVariables>;
 export declare const SetGridPermissionLimitsDocument: DocumentNode<SetGridPermissionLimitsMutation, SetGridPermissionLimitsMutationVariables>;
+export declare const SetGridOpenPermissionsDocument: DocumentNode<SetGridOpenPermissionsMutation, SetGridOpenPermissionsMutationVariables>;
 export declare const AssignGroupToGridDocument: DocumentNode<AssignGroupToGridMutation, AssignGroupToGridMutationVariables>;
 export declare const RevokeGroupFromGridDocument: DocumentNode<RevokeGroupFromGridMutation, RevokeGroupFromGridMutationVariables>;
 export declare const CreateGridChannelDocument: DocumentNode<CreateGridChannelMutation, CreateGridChannelMutationVariables>;