@casual-simulation/aux-records 3.8.1 → 3.10.2

package/RecordsServer.d.ts

@@ -10,7 +10,7 @@ import type { RateLimitController } from './RateLimitController';
 import type { PolicyController } from './PolicyController';
 import type { AIController } from './AIController';
 import type { WebsocketController } from './websockets/WebsocketController';
-import type { GenericHttpRequest, GenericHttpResponse, GenericWebsocketRequest, KnownErrorCodes, DenialReason, Procedure, ProcedureOutput, ProcedureOutputStream, Procedures } from '@casual-simulation/aux-common';
+import type { GenericHttpHeaders, GenericHttpRequest, GenericHttpResponse, GenericWebsocketRequest, KnownErrorCodes, DenialReason, Procedure, ProcedureOutput, ProcedureOutputStream, Procedures, SimpleError } from '@casual-simulation/aux-common';
 import type { ModerationController } from './ModerationController';
 import type { LoomController } from './LoomController';
 import type { WebhookRecordsController } from './webhooks/WebhookRecordsController';
@@ -19,6 +19,10 @@ import type { PackageRecordsController } from './packages/PackageRecordsControll
 import type { PackageVersionRecordsController } from './packages/version/PackageVersionRecordsController';
 import type { SearchRecordsController } from './search';
 import type { DatabaseRecordsController } from './database';
+import type { PurchasableItemRecordsController } from './purchasable-items/PurchasableItemRecordsController';
+import type { PurchasableItem } from './purchasable-items/PurchasableItemRecordsStore';
+import type { ContractRecordsController } from './contracts/ContractRecordsController';
+import type { ViewParams, ViewTemplateRenderer } from './ViewTemplateRenderer';
 export declare const NOT_LOGGED_IN_RESULT: {
     success: false;
     errorCode: "not_logged_in";
@@ -64,6 +68,11 @@ export declare const LOOM_NOT_SUPPORTED_RESULT: {
     errorCode: "not_supported";
     errorMessage: string;
 };
+export declare const STORE_NOT_SUPPORTED_RESULT: {
+    success: false;
+    errorCode: "not_supported";
+    errorMessage: string;
+};
 export declare const INSTS_NOT_SUPPORTED_RESULT: {
     success: false;
     errorCode: "not_supported";
@@ -74,27 +83,34 @@ export declare const MODERATION_NOT_SUPPORTED_RESULT: {
     errorCode: "not_supported";
     errorMessage: string;
 };
+export declare const XP_API_NOT_SUPPORTED_RESULT: {
+    success: false;
+    errorCode: "not_supported";
+    errorMessage: string;
+};
 /**
  * Defines a basic interface for an HTTP route.
  */
-export interface Route<T, TQuery = any> {
+export interface Route<TSchema extends z.ZodType | void, TQuery extends z.ZodType | void = void> {
     /**
      * The path that the route must match.
+     *
+     * If true, then the route will match all paths as a default route.
      */
-    path: string;
+    path: string | true;
     /**
      * The schema that should be used for the route.
      * If the method can contain a request body, then the schema applies to the body.
      * Otherwise, it will apply to the query parameters.
      */
-    schema?: z.ZodType<T, z.ZodTypeDef, any>;
+    schema?: TSchema;
     /**
      * The schema that should be used for the query parameters.
      * If omitted, then the query parameters will not be validated using this schema.
      *
      * Additionally, this only works if a schema is provided.
      */
-    querySchema?: z.ZodType<TQuery, z.ZodTypeDef, any>;
+    querySchema?: TQuery;
     /**
      * The method for the route.
      */
@@ -104,13 +120,18 @@ export interface Route<T, TQuery = any> {
      * If omitted, then the route will not be named.
      */
     name?: string;
+    /**
+     * The scope for the route.
+     * Used to filter requests based on their context.
+     */
+    scope?: 'player' | 'auth';
     /**
      * The handler that should be called when the route is matched.
      * @param request The request.
      * @param data The data that was parsed from the request.
      * @param query The query parameters that were parsed from the request.
      */
-    handler: (request: GenericHttpRequest, data?: T, query?: TQuery) => Promise<GenericHttpResponse>;
+    handler: (request: GenericHttpRequest, data?: z.output<TSchema>, query?: z.output<TQuery>) => Promise<GenericHttpResponse>;
     /**
      * The set of origins that are allowed for the route.
      * If true, then all origins are allowed.
@@ -225,6 +246,20 @@ export interface RecordsServerOptions {
      * If null, then database records are not supported.
      */
     databaseRecordsController?: DatabaseRecordsController | null;
+    /**
+     * The controller that should be used for handling contracts..
+     * If null, then contracts are not supported.
+     */
+    contractRecordsController?: ContractRecordsController | null;
+    /**
+     * The controller that should be used for handling purchasable items.
+     * If null, then purchasable items are not supported.
+     */
+    purchasableItemsController?: PurchasableItemRecordsController | null;
+    /**
+     * The interface that should be used for rendering view templates.
+     */
+    viewTemplateRenderer?: ViewTemplateRenderer | null;
 }
 /**
  * Defines a class that represents a generic HTTP server suitable for Records HTTP Requests.
@@ -248,6 +283,8 @@ export declare class RecordsServer {
     private _packageVersionController;
     private _searchRecordsController;
     private _databaseRecordsController;
+    private _contractRecordsController;
+    private _viewTemplateRenderer;
     /**
      * The set of origins that are allowed for API requests.
      */
@@ -259,6 +296,7 @@ export declare class RecordsServer {
     private _rateLimit;
     private _websocketRateLimit;
     private _policyController;
+    private _purchasableItems;
     /**
      * The map of paths to routes that they match.
      */
@@ -280,9 +318,14 @@ export declare class RecordsServer {
      * The set of procedures that the server has.
      */
     get procedures(): {
-        getUserInfo: Procedure<{
-            userId?: string;
-        }, import("./AuthController").GetUserInfoFailure | {
+        playerIndex: Procedure<void, import("@casual-simulation/aux-common").GenericResult<ViewParams, SimpleError>, void>;
+        playerVmIframe: Procedure<void, import("@casual-simulation/aux-common").GenericResult<ViewParams, SimpleError>, void>;
+        playerVmIframeDom: Procedure<void, import("@casual-simulation/aux-common").GenericResult<ViewParams, SimpleError>, void>;
+        authIndex: Procedure<void, import("@casual-simulation/aux-common").GenericResult<ViewParams, SimpleError>, void>;
+        authIframe: Procedure<void, import("@casual-simulation/aux-common").GenericResult<ViewParams, SimpleError>, void>;
+        getUserInfo: Procedure<z.ZodObject<{
+            userId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./AuthController").GetUserInfoFailure | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -298,163 +341,195 @@ export declare class RecordsServer {
             readonly privacyFeatures: import("@casual-simulation/aux-common").PrivacyFeatures;
             readonly displayName: string;
             readonly role: import("@casual-simulation/aux-common").UserRole;
-        }, any>;
-        isEmailValid: Procedure<{
-            email?: string;
-        }, import("./AuthController").IsValidEmailAddressResult, any>;
-        isDisplayNameValid: Procedure<{
-            displayName?: string;
-            name?: string;
-        }, import("./AuthController").IsValidDisplayNameResult, any>;
-        createAccount: Procedure<{}, import("./AuthController").CreateAccountResult | import("./AuthController").ValidateSessionKeyFailure | {
+            readonly contractFeatures: {
+                allowed: boolean;
+                currencyLimits: {
+                    [x: string]: {
+                        maxCost: number;
+                        minCost: number;
+                        fee?: {
+                            type: "percent";
+                            percent: number;
+                        } | {
+                            type: "fixed";
+                            amount: number;
+                        };
+                    };
+                };
+                maxItems?: number;
+            };
+            readonly stripeAccountId: string;
+            readonly stripeAccountStatus: import("./StripeInterface").StripeAccountStatus;
+            readonly stripeAccountRequirementsStatus: import("./StripeInterface").StripeRequirementsStatus;
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        isEmailValid: Procedure<z.ZodObject<{
+            email: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").IsValidEmailAddressResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        isDisplayNameValid: Procedure<z.ZodObject<{
+            displayName: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").IsValidDisplayNameResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        createAccount: Procedure<z.ZodObject<{}, z.core.$strip>, import("./AuthController").CreateAccountResult | import("./AuthController").ValidateSessionKeyFailure | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
-        }, any>;
-        listSessions: Procedure<{
-            expireTimeMs?: number;
-            userId?: string;
-        }, import("./AuthController").ListSessionsResult | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listSessions: Procedure<z.ZodPrefault<z.ZodObject<{
+            expireTimeMs: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+            userId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>, import("./AuthController").ListSessionsResult | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
-        }, any>;
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
         replaceSession: Procedure<void, import("./AuthController").ReplaceSessionResult | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
         }, void>;
-        revokeAllSessions: Procedure<{
-            userId?: string;
-        }, import("./AuthController").RevokeAllSessionsResult | {
+        revokeAllSessions: Procedure<z.ZodObject<{
+            userId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").RevokeAllSessionsResult | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
-        }, any>;
-        revokeSession: Procedure<{
-            userId?: string;
-            sessionId?: string;
-            sessionKey?: string;
-        }, import("./AuthController").RevokeSessionResult | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        revokeSession: Procedure<z.ZodObject<{
+            userId: z.ZodOptional<z.ZodString>;
+            sessionId: z.ZodOptional<z.ZodString>;
+            sessionKey: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").RevokeSessionResult | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
-        }, any>;
-        completeLogin: Procedure<{
-            userId?: string;
-            requestId?: string;
-            code?: string;
-        }, import("./AuthController").CompleteLoginResult, any>;
-        requestLogin: Procedure<{
-            address?: string;
-            addressType?: "email" | "phone";
-        }, import("./AuthController").LoginRequestResult, any>;
-        requestPrivoLogin: Procedure<{}, import("./AuthController").OpenIDLoginRequestResult, any>;
-        processOAuthCode: Procedure<{
-            code?: string;
-            state?: string;
-        }, import("./AuthController").ProcessOpenIDAuthorizationCodeResult, any>;
-        completeOAuthLogin: Procedure<{
-            requestId?: string;
-        }, import("./AuthController").CompleteOpenIDLoginResult, any>;
-        requestPrivoSignUp: Procedure<{
-            email?: string;
-            parentEmail?: string;
-            name?: string;
-            dateOfBirth?: Date;
-            displayName?: string;
-        }, import("./AuthController").PrivoSignUpRequestResult, any>;
-        requestPrivacyFeaturesChange: Procedure<{
-            userId?: string;
-        }, import("./AuthController").RequestPrivacyFeaturesChangeResult, any>;
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        completeLogin: Procedure<z.ZodObject<{
+            userId: z.ZodString;
+            requestId: z.ZodString;
+            code: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").CompleteLoginResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        requestLogin: Procedure<z.ZodObject<{
+            address: z.ZodString;
+            addressType: z.ZodEnum<{
+                email: "email";
+                phone: "phone";
+            }>;
+            loginStudioId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            comId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            customDomain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, import("./AuthController").LoginRequestResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        requestPrivoLogin: Procedure<z.ZodObject<{}, z.core.$strip>, import("./AuthController").OpenIDLoginRequestResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        processOAuthCode: Procedure<z.ZodObject<{
+            code: z.ZodString;
+            state: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ProcessOpenIDAuthorizationCodeResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        completeOAuthLogin: Procedure<z.ZodObject<{
+            requestId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").CompleteOpenIDLoginResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        requestPrivoSignUp: Procedure<z.ZodObject<{
+            email: z.ZodOptional<z.ZodEmail>;
+            parentEmail: z.ZodOptional<z.ZodEmail>;
+            name: z.ZodString;
+            dateOfBirth: z.ZodCoercedDate<unknown>;
+            displayName: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").PrivoSignUpRequestResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        requestPrivacyFeaturesChange: Procedure<z.ZodObject<{
+            userId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").RequestPrivacyFeaturesChangeResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
         getWebAuthnRegistrationOptions: Procedure<void, import("./AuthController").RequestWebAuthnRegistrationResult | import("./AuthController").ValidateSessionKeyFailure, void>;
-        registerWebAuthn: Procedure<{
-            response?: {
-                id?: string;
-                rawId?: string;
-                response?: {
-                    clientDataJSON?: string;
-                    attestationObject?: string;
-                    authenticatorData?: string;
-                    transports?: string[];
-                    publicKeyAlgorithm?: number;
-                    publicKey?: string;
-                };
-                authenticatorAttachment?: "cross-platform" | "platform";
-                clientExtensionResults?: {
-                    appid?: boolean;
-                    credProps?: {
-                        rk?: boolean;
-                    };
-                    hmacCreateSecret?: boolean;
-                };
-                type?: "public-key";
-            };
-        }, import("./AuthController").CompleteWebAuthnRegistrationResult | import("./AuthController").ValidateSessionKeyFailure, any>;
+        registerWebAuthn: Procedure<z.ZodObject<{
+            response: z.ZodObject<{
+                id: z.ZodString;
+                rawId: z.ZodString;
+                response: z.ZodObject<{
+                    clientDataJSON: z.ZodString;
+                    attestationObject: z.ZodString;
+                    authenticatorData: z.ZodOptional<z.ZodString>;
+                    transports: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    publicKeyAlgorithm: z.ZodOptional<z.ZodNumber>;
+                    publicKey: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                authenticatorAttachment: z.ZodOptional<z.ZodEnum<{
+                    "cross-platform": "cross-platform";
+                    platform: "platform";
+                }>>;
+                clientExtensionResults: z.ZodObject<{
+                    appid: z.ZodOptional<z.ZodBoolean>;
+                    credProps: z.ZodOptional<z.ZodObject<{
+                        rk: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    hmacCreateSecret: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>;
+                type: z.ZodLiteral<"public-key">;
+            }, z.core.$strip>;
+        }, z.core.$strip>, import("./AuthController").CompleteWebAuthnRegistrationResult | import("./AuthController").ValidateSessionKeyFailure, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
         getWebAuthnLoginOptions: Procedure<void, import("./AuthController").RequestWebAuthnLoginResult, void>;
-        completeWebAuthnLogin: Procedure<{
-            requestId?: string;
-            response?: {
-                id?: string;
-                rawId?: string;
-                response?: {
-                    clientDataJSON?: string;
-                    authenticatorData?: string;
-                    signature?: string;
-                    userHandle?: string;
-                };
-                authenticatorAttachment?: "cross-platform" | "platform";
-                clientExtensionResults?: {
-                    appid?: boolean;
-                    credProps?: {
-                        rk?: boolean;
-                    };
-                    hmacCreateSecret?: boolean;
-                };
-                type?: "public-key";
-            };
-        }, import("./AuthController").CompleteWebAuthnLoginResult, any>;
+        completeWebAuthnLogin: Procedure<z.ZodObject<{
+            requestId: z.ZodString;
+            response: z.ZodObject<{
+                id: z.ZodString;
+                rawId: z.ZodString;
+                response: z.ZodObject<{
+                    clientDataJSON: z.ZodString;
+                    authenticatorData: z.ZodString;
+                    signature: z.ZodString;
+                    userHandle: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                authenticatorAttachment: z.ZodOptional<z.ZodEnum<{
+                    "cross-platform": "cross-platform";
+                    platform: "platform";
+                }>>;
+                clientExtensionResults: z.ZodObject<{
+                    appid: z.ZodOptional<z.ZodBoolean>;
+                    credProps: z.ZodOptional<z.ZodObject<{
+                        rk: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    hmacCreateSecret: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>;
+                type: z.ZodLiteral<"public-key">;
+            }, z.core.$strip>;
+        }, z.core.$strip>, import("./AuthController").CompleteWebAuthnLoginResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
         listUserAuthenticators: Procedure<void, import("./AuthController").ListUserAuthenticatorsResult | import("./AuthController").ValidateSessionKeyFailure, void>;
-        deleteUserAuthenticator: Procedure<{
-            authenticatorId?: string;
-        }, import("./AuthController").DeleteUserAuthenticatorResult | import("./AuthController").ValidateSessionKeyFailure, any>;
-        createMeetToken: Procedure<{
-            roomName?: string;
-            userName?: string;
-        }, import("./LivekitEvents").IssueMeetTokenResult, any>;
-        createRecord: Procedure<{
-            recordName?: string;
-            ownerId?: string;
-            studioId?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").CreateRecordResult, any>;
-        addEventCount: Procedure<{
-            recordKey?: string;
-            eventName?: string;
-            count?: number;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./EventRecordsController").AddCountResult, any>;
-        getEventCount: Procedure<{
-            recordName?: string;
-            eventName?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./EventRecordsController").GetCountResult, any>;
-        listEvents: Procedure<{
-            recordName?: string;
-            eventName?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./EventRecordsController").ListEventsResult, any>;
-        updateEvent: Procedure<{
-            recordKey?: string;
-            eventName?: string;
-            count?: number;
-            markers?: [string, ...string[]];
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./EventRecordsController").UpdateEventRecordResult, any>;
-        deleteManualData: Procedure<{
-            recordKey?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").EraseDataSuccess | import("./DataRecordsController").EraseDataFailure | {
+        deleteUserAuthenticator: Procedure<z.ZodObject<{
+            authenticatorId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").DeleteUserAuthenticatorResult | import("./AuthController").ValidateSessionKeyFailure, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        createMeetToken: Procedure<z.ZodObject<{
+            roomName: z.ZodString;
+            userName: z.ZodString;
+        }, z.core.$strip>, import("./LivekitEvents").IssueMeetTokenResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        createRecord: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            ownerId: z.ZodOptional<z.ZodString>;
+            studioId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").CreateRecordResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        addEventCount: Procedure<z.ZodObject<{
+            recordKey: z.ZodString;
+            eventName: z.ZodString;
+            count: z.ZodNumber;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./EventRecordsController").AddCountResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getEventCount: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            eventName: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./EventRecordsController").GetCountResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listEvents: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            eventName: z.ZodOptional<z.ZodString>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./EventRecordsController").ListEventsResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        updateEvent: Procedure<z.ZodObject<{
+            recordKey: z.ZodString;
+            eventName: z.ZodString;
+            count: z.ZodOptional<z.ZodNumber>;
+            markers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./EventRecordsController").UpdateEventRecordResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        deleteManualData: Procedure<z.ZodObject<{
+            recordKey: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").EraseDataSuccess | import("./DataRecordsController").EraseDataFailure | {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "recordKey is required and must be a string.";
@@ -462,12 +537,12 @@ export declare class RecordsServer {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "address is required and must be a string.";
-        }, any>;
-        getManualData: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").GetDataSuccess | import("./DataRecordsController").GetDataFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getManualData: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").GetDataSuccess | import("./DataRecordsController").GetDataFailure | {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "recordName is required and must be a string.";
@@ -475,16 +550,16 @@ export declare class RecordsServer {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "address is required and must be a string.";
-        }, any>;
-        recordManualData: Procedure<{
-            recordKey?: string;
-            address?: string;
-            data?: any;
-            updatePolicy?: true | string[];
-            deletePolicy?: true | string[];
-            markers?: [string, ...string[]];
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").RecordDataSuccess | import("./DataRecordsController").RecordDataFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        recordManualData: Procedure<z.ZodObject<{
+            recordKey: z.ZodString;
+            address: z.ZodString;
+            data: z.ZodAny;
+            updatePolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodArray<z.ZodString>]>>;
+            deletePolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodArray<z.ZodString>]>>;
+            markers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").RecordDataSuccess | import("./DataRecordsController").RecordDataFailure | {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "recordKey is required and must be a string.";
@@ -496,22 +571,22 @@ export declare class RecordsServer {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "data is required.";
-        }, any>;
-        getFile: Procedure<{
-            recordName?: string;
-            fileName?: string;
-            fileUrl?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsStore").GetFileNameFromUrlFailure | import("./FileRecordsController").ReadFileSuccess | import("./FileRecordsController").ReadFileFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getFile: Procedure<z.ZodObject<{
+            recordName: z.ZodOptional<z.ZodString>;
+            fileName: z.ZodOptional<z.ZodString>;
+            fileUrl: z.ZodOptional<z.ZodString>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsStore").GetFileNameFromUrlFailure | import("./FileRecordsController").ReadFileSuccess | import("./FileRecordsController").ReadFileFailure | {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: string;
-        }, any>;
-        listFiles: Procedure<{
-            recordName?: string;
-            fileName?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsController").ListFilesSuccess | import("./FileRecordsController").ListFilesFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listFiles: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            fileName: z.ZodOptional<z.ZodString>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsController").ListFilesSuccess | import("./FileRecordsController").ListFilesFailure | {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "recordName must be a string.";
@@ -519,12 +594,12 @@ export declare class RecordsServer {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "fileName must be a string.";
-        }, any>;
-        eraseFile: Procedure<{
-            recordKey?: string;
-            fileUrl?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsStore").GetFileNameFromUrlSuccess | import("./FileRecordsStore").GetFileNameFromUrlFailure | import("./FileRecordsController").EraseFileFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        eraseFile: Procedure<z.ZodObject<{
+            recordKey: z.ZodString;
+            fileUrl: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsStore").GetFileNameFromUrlSuccess | import("./FileRecordsStore").GetFileNameFromUrlFailure | import("./FileRecordsController").EraseFileFailure | {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "recordKey is required and must be a string.";
@@ -532,16 +607,16 @@ export declare class RecordsServer {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "fileUrl is required and must be a string.";
-        }, any>;
-        recordFile: Procedure<{
-            recordKey?: string;
-            fileSha256Hex?: string;
-            fileByteLength?: number;
-            fileMimeType?: string;
-            fileDescription?: string;
-            markers?: [string, ...string[]];
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsController").RecordFileSuccess | import("./FileRecordsController").RecordFileFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        recordFile: Procedure<z.ZodObject<{
+            recordKey: z.ZodString;
+            fileSha256Hex: z.ZodString;
+            fileByteLength: z.ZodInt;
+            fileMimeType: z.ZodString;
+            fileDescription: z.ZodOptional<z.ZodString>;
+            markers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsController").RecordFileSuccess | import("./FileRecordsController").RecordFileFailure | {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "recordKey is required and must be a string.";
@@ -561,17 +636,17 @@ export declare class RecordsServer {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "fileDescription must be a string.";
-        }, any>;
-        updateFile: Procedure<{
-            recordKey?: string;
-            fileUrl?: string;
-            markers?: [string, ...string[]];
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsStore").GetFileNameFromUrlFailure | import("./FileRecordsController").UpdateFileRecordSuccess | import("./FileRecordsController").UpdateFileRecordFailure, any>;
-        scanFileForModeration: Procedure<{
-            recordName?: string;
-            fileName?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./ModerationController").ScanFileSuccess | import("./ModerationController").ScanFileFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        updateFile: Procedure<z.ZodObject<{
+            recordKey: z.ZodString;
+            fileUrl: z.ZodString;
+            markers: z.ZodArray<z.ZodString>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsStore").GetFileNameFromUrlFailure | import("./FileRecordsController").UpdateFileRecordSuccess | import("./FileRecordsController").UpdateFileRecordFailure, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        scanFileForModeration: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            fileName: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./ModerationController").ScanFileSuccess | import("./ModerationController").ScanFileFailure | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -579,8 +654,8 @@ export declare class RecordsServer {
             readonly success: false;
             readonly errorCode: "not_authorized";
             readonly errorMessage: "You are not authorized to perform this action.";
-        }, any>;
-        scheduleModerationScans: Procedure<{}, import("./AuthController").ValidateSessionKeyFailure | import("./ModerationController").ScheduleModerationScansSuccess | import("./ModerationController").ScheduleModerationScansFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        scheduleModerationScans: Procedure<z.ZodObject<{}, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./ModerationController").ScheduleModerationScansSuccess | import("./ModerationController").ScheduleModerationScansFailure | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -588,12 +663,12 @@ export declare class RecordsServer {
             readonly success: false;
             readonly errorCode: "not_authorized";
             readonly errorMessage: "You are not authorized to perform this action.";
-        }, any>;
-        eraseData: Procedure<{
-            recordKey?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").EraseDataSuccess | import("./DataRecordsController").EraseDataFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        eraseData: Procedure<z.ZodObject<{
+            recordKey: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").EraseDataSuccess | import("./DataRecordsController").EraseDataFailure | {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "recordKey is required and must be a string.";
@@ -601,12 +676,12 @@ export declare class RecordsServer {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "address is required and must be a string.";
-        }, any>;
-        getData: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").GetDataSuccess | import("./DataRecordsController").GetDataFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getData: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").GetDataSuccess | import("./DataRecordsController").GetDataFailure | {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "recordName is required and must be a string.";
@@ -614,14 +689,17 @@ export declare class RecordsServer {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "address is required and must be a string.";
-        }, any>;
-        listData: Procedure<{
-            recordName?: string;
-            address?: string;
-            marker?: string;
-            sort?: "ascending" | "descending";
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").ListDataSuccess | import("./DataRecordsController").ListDataFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listData: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            marker: z.ZodOptional<z.ZodString>;
+            sort: z.ZodOptional<z.ZodEnum<{
+                ascending: "ascending";
+                descending: "descending";
+            }>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").ListDataSuccess | import("./DataRecordsController").ListDataFailure | {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "recordName is required and must be a string.";
@@ -629,16 +707,16 @@ export declare class RecordsServer {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "address must be null or a string.";
-        }, any>;
-        recordData: Procedure<{
-            recordKey?: string;
-            address?: string;
-            data?: any;
-            updatePolicy?: true | string[];
-            deletePolicy?: true | string[];
-            markers?: [string, ...string[]];
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").RecordDataSuccess | import("./DataRecordsController").RecordDataFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        recordData: Procedure<z.ZodObject<{
+            recordKey: z.ZodString;
+            address: z.ZodString;
+            data: z.ZodAny;
+            updatePolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodArray<z.ZodString>]>>;
+            deletePolicy: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodArray<z.ZodString>]>>;
+            markers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./DataRecordsController").RecordDataSuccess | import("./DataRecordsController").RecordDataFailure | {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "recordKey is required and must be a string.";
@@ -650,302 +728,365 @@ export declare class RecordsServer {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "data is required.";
-        }, any>;
-        recordWebhook: Procedure<{
-            recordName?: string;
-            item?: {
-                address?: string;
-                targetResourceKind?: "data" | "file";
-                targetRecordName?: string;
-                targetAddress?: string;
-                markers?: [string, ...string[]];
-            } | {
-                address?: string;
-                targetResourceKind?: "inst";
-                targetRecordName?: string;
-                targetAddress?: string;
-                markers?: [string, ...string[]];
-            };
-            instances?: string[];
-        }, import("./crud").CrudRecordItemResult, any>;
-        getWebhook: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./crud").CrudGetItemResult<any>, any>;
-        listWebhooks: Procedure<{
-            recordName?: string;
-            address?: string;
-            marker?: string;
-            sort?: "ascending" | "descending";
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<any> | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        recordWebhook: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            item: z.ZodNonOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                address: z.ZodString;
+                targetResourceKind: z.ZodEnum<{
+                    data: "data";
+                    file: "file";
+                }>;
+                targetRecordName: z.ZodString;
+                targetAddress: z.ZodString;
+                markers: z.ZodPrefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>, z.ZodObject<{
+                address: z.ZodString;
+                targetResourceKind: z.ZodLiteral<"inst">;
+                targetRecordName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                targetAddress: z.ZodString;
+                markers: z.ZodPrefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>], "targetResourceKind">>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudRecordItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getWebhook: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudGetItemResult<any>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listWebhooks: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            marker: z.ZodOptional<z.ZodString>;
+            sort: z.ZodOptional<z.ZodEnum<{
+                ascending: "ascending";
+                descending: "descending";
+            }>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<any> | {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        runWebhook: Procedure<any, import("./AuthController").ValidateSessionKeyFailure | import("./webhooks/WebhookRecordsController").HandleWebhookFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        runWebhook: Procedure<z.ZodAny, import("./AuthController").ValidateSessionKeyFailure | import("./webhooks/WebhookRecordsController").HandleWebhookFailure | {
             success: true;
             response: GenericHttpResponse;
-        }, z.objectOutputType<{
+        }, z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$catchall<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>>;
+        eraseWebhook: Procedure<z.ZodObject<{
             recordName: z.ZodString;
             address: z.ZodString;
-            instances: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], unknown>>;
-        }, z.ZodString, "strip">>;
-        eraseWebhook: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./crud").CrudEraseItemResult, any>;
-        listWebhookRuns: Procedure<{
-            recordName?: string;
-            address?: string;
-            requestTimeMs?: number;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<import("./webhooks").WebhookRunInfo> | {
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudEraseItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listWebhookRuns: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            requestTimeMs: z.ZodOptional<z.ZodInt>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<import("./webhooks").WebhookRunInfo> | {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        getWebhookRun: Procedure<{
-            runId?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./webhooks/WebhookRecordsController").GetWebhookRunSuccess | import("./webhooks/WebhookRecordsController").GetWebhookRunFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getWebhookRun: Procedure<z.ZodObject<{
+            runId: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./webhooks/WebhookRecordsController").GetWebhookRunSuccess | import("./webhooks/WebhookRecordsController").GetWebhookRunFailure | {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        recordNotification: Procedure<{
-            recordName?: string;
-            item?: {
-                address?: string;
-                description?: string;
-                markers?: [string, ...string[]];
-            };
-            instances?: string[];
-        }, import("./crud").CrudRecordItemResult, any>;
-        getNotification: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./crud").CrudGetItemResult<any>, any>;
-        listNotifications: Procedure<{
-            recordName?: string;
-            address?: string;
-            marker?: string;
-            sort?: "ascending" | "descending";
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<any> | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        recordNotification: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            item: z.ZodNonOptional<z.ZodObject<{
+                address: z.ZodString;
+                description: z.ZodString;
+                markers: z.ZodPrefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudRecordItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getNotification: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudGetItemResult<any>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listNotifications: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            marker: z.ZodOptional<z.ZodString>;
+            sort: z.ZodOptional<z.ZodEnum<{
+                ascending: "ascending";
+                descending: "descending";
+            }>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<any> | {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        listNotificationSubscriptions: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./notifications").ListSubscriptionsResult, any>;
-        listUserNotificationSubscriptions: Procedure<{
-            instances?: string[];
-        }, import("./notifications").ListSubscriptionsResult, any>;
-        eraseNotification: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./crud").CrudEraseItemResult, any>;
-        registerPushSubscription: Procedure<{
-            pushSubscription?: {
-                endpoint?: string;
-                expirationTime?: number;
-                keys?: Record<string, string>;
-            };
-            instances?: string[];
-        }, import("./notifications").RegisterPushSubscriptionResult, any>;
-        subscribeToNotification: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-            pushSubscription?: {
-                endpoint?: string;
-                expirationTime?: number;
-                keys?: Record<string, string>;
-            };
-        }, import("./notifications").SubscribeToNotificationResult, any>;
-        unsubscribeFromNotification: Procedure<{
-            subscriptionId?: string;
-            instances?: string[];
-        }, import("./notifications").UnsubscribeToNotificationResult, any>;
-        sendNotification: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-            payload?: {
-                title?: string;
-                body?: string;
-                icon?: string;
-                badge?: string;
-                silent?: boolean;
-                tag?: string;
-                timestamp?: number;
-                action?: {
-                    type?: "open_url";
-                    url?: string;
-                } | {
-                    type?: "webhook";
-                    method?: "GET" | "POST";
-                    url?: string;
-                    headers?: Record<string, string>;
-                };
-                actions?: {
-                    title?: string;
-                    icon?: string;
-                    action?: {
-                        type?: "open_url";
-                        url?: string;
-                    } | {
-                        type?: "webhook";
-                        method?: "GET" | "POST";
-                        url?: string;
-                        headers?: Record<string, string>;
-                    };
-                }[];
-            };
-            topic?: string;
-        }, import("./notifications").SendNotificationResult, any>;
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listNotificationSubscriptions: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./notifications").ListSubscriptionsResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listUserNotificationSubscriptions: Procedure<z.ZodObject<{
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./notifications").ListSubscriptionsResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        eraseNotification: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudEraseItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        registerPushSubscription: Procedure<z.ZodObject<{
+            pushSubscription: z.ZodObject<{
+                endpoint: z.ZodString;
+                expirationTime: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+                keys: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, z.core.$strip>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./notifications").RegisterPushSubscriptionResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        subscribeToNotification: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+            pushSubscription: z.ZodObject<{
+                endpoint: z.ZodString;
+                expirationTime: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+                keys: z.ZodRecord<z.ZodString, z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, import("./notifications").SubscribeToNotificationResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        unsubscribeFromNotification: Procedure<z.ZodObject<{
+            subscriptionId: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./notifications").UnsubscribeToNotificationResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        sendNotification: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+            payload: z.ZodObject<{
+                title: z.ZodString;
+                body: z.ZodString;
+                icon: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                badge: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                silent: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+                tag: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                timestamp: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+                action: z.ZodNullable<z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"open_url">;
+                    url: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    type: z.ZodLiteral<"webhook">;
+                    method: z.ZodEnum<{
+                        GET: "GET";
+                        POST: "POST";
+                    }>;
+                    url: z.ZodString;
+                    headers: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+                }, z.core.$strip>], "type">>>;
+                actions: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    title: z.ZodString;
+                    icon: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                    action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        type: z.ZodLiteral<"open_url">;
+                        url: z.ZodString;
+                    }, z.core.$strip>, z.ZodObject<{
+                        type: z.ZodLiteral<"webhook">;
+                        method: z.ZodEnum<{
+                            GET: "GET";
+                            POST: "POST";
+                        }>;
+                        url: z.ZodString;
+                        headers: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+                    }, z.core.$strip>], "type">;
+                }, z.core.$strip>>>>;
+            }, z.core.$strip>;
+            topic: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./notifications").SendNotificationResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
         getNotificationsApplicationServerKey: Procedure<void, import("./notifications").GetApplicationServerKeyResult, void>;
-        getPackage: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./crud").CrudGetItemResult<any>, any>;
-        recordPackage: Procedure<{
-            recordName?: string;
-            item?: {
-                address?: string;
-                markers?: [string, ...string[]];
-            };
-            instances?: string[];
-        }, import("./crud").CrudRecordItemResult, any>;
-        erasePackage: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./crud").CrudEraseItemResult, any>;
-        listPackages: Procedure<{
-            recordName?: string;
-            address?: string;
-            marker?: string;
-            sort?: "ascending" | "descending";
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<any> | {
+        getPackage: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudGetItemResult<any>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        recordPackage: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            item: z.ZodNonOptional<z.ZodObject<{
+                address: z.ZodString;
+                markers: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudRecordItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        erasePackage: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudEraseItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listPackages: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            marker: z.ZodOptional<z.ZodString>;
+            sort: z.ZodOptional<z.ZodEnum<{
+                ascending: "ascending";
+                descending: "descending";
+            }>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<any> | {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        getPackageVersion: Procedure<{
-            recordName?: string;
-            address?: string;
-            major?: number;
-            minor?: number;
-            patch?: number;
-            tag?: string;
-            sha256?: string;
-            instances?: string[];
-            key?: string;
-        }, import("./packages/version/PackageVersionRecordsController").GetPackageVersionResult, any>;
-        recordPackageVersion: Procedure<{
-            recordName?: string;
-            item?: {
-                address?: string;
-                key?: {
-                    major?: number;
-                    minor?: number;
-                    patch?: number;
-                    tag?: string;
-                };
-                auxFileRequest?: {
-                    fileSha256Hex?: string;
-                    fileByteLength?: number;
-                    fileMimeType?: string;
-                    fileDescription?: string;
-                };
-                entitlements?: {
-                    feature?: "search" | "inst" | "data" | "event" | "file" | "webhook" | "notification" | "package" | "database" | "permissions" | "ai";
-                    scope?: "shared" | "personal" | "owned" | "studio" | "designated";
-                    designatedRecords?: string[];
-                }[];
-                description?: string;
-                markers?: [string, ...string[]];
-            };
-            instances?: string[];
-        }, import("./packages/version/PackageVersionRecordsController").RecordPackageVersionResult, any>;
-        listPackageVersions: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<import("./packages/version/PackageVersionRecordsStore").PackageRecordVersion> | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getPackageVersion: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            major: z.ZodNullable<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+            minor: z.ZodNullable<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+            patch: z.ZodNullable<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+            tag: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            sha256: z.ZodOptional<z.ZodString>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+            key: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./packages/version/PackageVersionRecordsController").GetPackageVersionResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        recordPackageVersion: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            item: z.ZodObject<{
+                address: z.ZodString;
+                key: z.ZodObject<{
+                    major: z.ZodInt;
+                    minor: z.ZodInt;
+                    patch: z.ZodInt;
+                    tag: z.ZodPrefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+                }, z.core.$strip>;
+                auxFileRequest: z.ZodObject<{
+                    fileSha256Hex: z.ZodString;
+                    fileByteLength: z.ZodInt;
+                    fileMimeType: z.ZodString;
+                    fileDescription: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                entitlements: z.ZodArray<z.ZodObject<{
+                    feature: z.ZodEnum<{
+                        search: "search";
+                        inst: "inst";
+                        file: "file";
+                        event: "event";
+                        data: "data";
+                        webhook: "webhook";
+                        notification: "notification";
+                        package: "package";
+                        database: "database";
+                        permissions: "permissions";
+                        ai: "ai";
+                    }>;
+                    scope: z.ZodEnum<{
+                        shared: "shared";
+                        personal: "personal";
+                        owned: "owned";
+                        studio: "studio";
+                        designated: "designated";
+                    }>;
+                    designatedRecords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+                description: z.ZodString;
+                markers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./packages/version/PackageVersionRecordsController").RecordPackageVersionResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listPackageVersions: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<import("./packages/version/PackageVersionRecordsStore").PackageRecordVersion> | {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        erasePackageVersion: Procedure<{
-            recordName?: string;
-            address?: string;
-            key?: {
-                major?: number;
-                minor?: number;
-                patch?: number;
-                tag?: string;
-            };
-            instances?: string[];
-        }, import("./crud").CrudEraseItemResult, any>;
-        reviewPackageVersion: Procedure<{
-            packageVersionId?: string;
-            review?: {
-                id?: string;
-                approved?: boolean;
-                approvalType?: "normal" | "super";
-                reviewStatus?: "pending" | "approved" | "rejected";
-                reviewComments?: string;
-            };
-        }, import("./packages/version/PackageVersionRecordsController").ReviewPackageVersionResult, any>;
-        installPackage: Procedure<{
-            recordName?: string;
-            inst?: string;
-            branch?: string;
-            instances?: string[];
-            package?: {
-                recordName?: string;
-                address?: string;
-                key?: string | {
-                    major?: number;
-                    minor?: number;
-                    patch?: number;
-                    tag?: string;
-                    sha256?: string;
-                };
-            };
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./websockets/WebsocketController").LoadPackageResult | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        erasePackageVersion: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            key: z.ZodObject<{
+                major: z.ZodInt;
+                minor: z.ZodInt;
+                patch: z.ZodInt;
+                tag: z.ZodPrefault<z.ZodString>;
+            }, z.core.$strip>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudEraseItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        reviewPackageVersion: Procedure<z.ZodObject<{
+            packageVersionId: z.ZodString;
+            review: z.ZodObject<{
+                id: z.ZodOptional<z.ZodString>;
+                approved: z.ZodBoolean;
+                approvalType: z.ZodNullable<z.ZodEnum<{
+                    normal: "normal";
+                    super: "super";
+                }>>;
+                reviewStatus: z.ZodEnum<{
+                    pending: "pending";
+                    rejected: "rejected";
+                    approved: "approved";
+                }>;
+                reviewComments: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>, import("./packages/version/PackageVersionRecordsController").ReviewPackageVersionResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        installPackage: Procedure<z.ZodObject<{
+            recordName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            inst: z.ZodString;
+            branch: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+            downgrade: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
+            package: z.ZodObject<{
+                recordName: z.ZodString;
+                address: z.ZodString;
+                key: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    major: z.ZodNullable<z.ZodOptional<z.ZodInt>>;
+                    minor: z.ZodNullable<z.ZodOptional<z.ZodInt>>;
+                    patch: z.ZodNullable<z.ZodOptional<z.ZodInt>>;
+                    tag: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                    sha256: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                }, z.core.$strip>]>>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./websockets/WebsocketController").LoadPackageResult | {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        listInstalledPackages: Procedure<{
-            recordName?: string;
-            inst?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./websockets/WebsocketController").ListInstalledPackagesResult | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listInstalledPackages: Procedure<z.ZodObject<{
+            recordName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            inst: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./websockets/WebsocketController").ListInstalledPackagesResult | {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        recordSearchCollection: Procedure<{
-            recordName?: string;
-            item?: {
-                address?: string;
-                markers?: [string, ...string[]];
-                schema?: z.objectOutputType<{}, z.ZodObject<{
-                    type: z.ZodEnum<["string", "string[]", "int32", "int32[]", "int64", "int64[]", "float", "float[]", "bool", "bool[]", "geopoint", "geopoint[]", "geopolygon", "object", "object[]", "string*", "image", "auto"]>;
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        recordSearchCollection: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            item: z.ZodNonOptional<z.ZodObject<{
+                address: z.ZodString;
+                markers: z.ZodArray<z.ZodString>;
+                schema: z.ZodObject<{}, z.core.$catchall<z.ZodObject<{
+                    type: z.ZodEnum<{
+                        string: "string";
+                        object: "object";
+                        image: "image";
+                        float: "float";
+                        auto: "auto";
+                        int32: "int32";
+                        int64: "int64";
+                        "string[]": "string[]";
+                        "int32[]": "int32[]";
+                        "int64[]": "int64[]";
+                        "float[]": "float[]";
+                        bool: "bool";
+                        "bool[]": "bool[]";
+                        geopoint: "geopoint";
+                        "geopoint[]": "geopoint[]";
+                        geopolygon: "geopolygon";
+                        "object[]": "object[]";
+                        "string*": "string*";
+                    }>;
                     optional: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
                     index: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
                     store: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
@@ -954,401 +1095,641 @@ export declare class RecordsServer {
                     locale: z.ZodNullable<z.ZodOptional<z.ZodString>>;
                     stem: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
                     drop: z.ZodNullable<z.ZodOptional<z.ZodBoolean>>;
-                }, "strip", z.ZodTypeAny, {
-                    type?: "string" | "object" | "float" | "auto" | "image" | "string[]" | "int32" | "int32[]" | "int64" | "int64[]" | "float[]" | "bool" | "bool[]" | "geopoint" | "geopoint[]" | "geopolygon" | "object[]" | "string*";
-                    optional?: boolean;
-                    index?: boolean;
-                    store?: boolean;
-                    sort?: boolean;
-                    infix?: boolean;
-                    locale?: string;
-                    stem?: boolean;
-                    drop?: boolean;
-                }, {
-                    type?: "string" | "object" | "float" | "auto" | "image" | "string[]" | "int32" | "int32[]" | "int64" | "int64[]" | "float[]" | "bool" | "bool[]" | "geopoint" | "geopoint[]" | "geopolygon" | "object[]" | "string*";
-                    optional?: boolean;
-                    index?: boolean;
-                    store?: boolean;
-                    sort?: boolean;
-                    infix?: boolean;
-                    locale?: string;
-                    stem?: boolean;
-                    drop?: boolean;
-                }>, "strip">;
-            };
-            instances?: string[];
-        }, import("./crud").CrudRecordItemResult, any>;
-        getSearchCollection: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./crud").CrudGetItemResult<any>, any>;
-        eraseSearchCollection: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./crud").CrudEraseItemResult, any>;
-        listSearchCollections: Procedure<{
-            recordName?: string;
-            address?: string;
-            marker?: string;
-            sort?: "ascending" | "descending";
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<any> | {
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudRecordItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getSearchCollection: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudGetItemResult<any>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        eraseSearchCollection: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudEraseItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listSearchCollections: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            marker: z.ZodOptional<z.ZodString>;
+            sort: z.ZodOptional<z.ZodEnum<{
+                ascending: "ascending";
+                descending: "descending";
+            }>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<any> | {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        recordSearchDocument: Procedure<{
-            recordName?: string;
-            address?: string;
-            document?: z.objectOutputType<{
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        recordSearchDocument: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            document: z.ZodObject<{
                 recordName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
                 address: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-                resourceKind: z.ZodNullable<z.ZodOptional<z.ZodEnum<["data", "file", "event", "marker", "role", "inst", "loom", "ai.sloyd", "ai.hume", "ai.openai.realtime", "webhook", "notification", "package", "package.version", "search", "database"]>>>;
-            }, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodBoolean, "many">, z.ZodEffects<z.ZodObject<{}, "strip", z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.objectOutputType<{}, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "strip">, z.objectInputType<{}, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "strip">>, z.objectOutputType<{}, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "strip">, z.objectInputType<{}, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>, "strip">>]>, "strip">;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | {
+                resourceKind: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+                    search: "search";
+                    inst: "inst";
+                    file: "file";
+                    event: "event";
+                    role: "role";
+                    data: "data";
+                    marker: "marker";
+                    loom: "loom";
+                    "ai.sloyd": "ai.sloyd";
+                    "ai.hume": "ai.hume";
+                    "ai.openai.realtime": "ai.openai.realtime";
+                    webhook: "webhook";
+                    notification: "notification";
+                    package: "package";
+                    "package.version": "package.version";
+                    database: "database";
+                    purchasableItem: "purchasableItem";
+                    contract: "contract";
+                    invoice: "invoice";
+                }>>>;
+            }, z.core.$catchall<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>, z.ZodArray<z.ZodBoolean>, z.ZodObject<{}, z.core.$catchall<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>]>>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
-        } | import("@casual-simulation/aux-common").GenericResult<import("./search").SearchDocumentInfo, import("@casual-simulation/aux-common").SimpleError>, any>;
-        eraseSearchDocument: Procedure<{
-            recordName?: string;
-            address?: string;
-            documentId?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | {
+        } | import("@casual-simulation/aux-common").GenericResult<import("./search").SearchDocumentInfo, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        eraseSearchDocument: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            documentId: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
-        } | import("@casual-simulation/aux-common").GenericResult<import("./search").SearchDocumentInfo, import("@casual-simulation/aux-common").SimpleError>, any>;
-        syncSearchRecord: Procedure<{
-            recordName?: string;
-            address?: string;
-            targetRecordName?: string;
-            targetResourceKind?: "data";
-            targetMarker?: string;
-            targetMapping?: [string, string, ...unknown[]][];
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | {
+        } | import("@casual-simulation/aux-common").GenericResult<import("./search").SearchDocumentInfo, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        syncSearchRecord: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            targetRecordName: z.ZodString;
+            targetResourceKind: z.ZodEnum<{
+                data: "data";
+            }>;
+            targetMarker: z.ZodString;
+            targetMapping: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
         } | import("@casual-simulation/aux-common").GenericResult<{
             syncId: string;
-        }, import("@casual-simulation/aux-common").SimpleError>, any>;
-        unsyncSearchRecord: Procedure<{
-            syncId?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | {
+        }, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        unsyncSearchRecord: Procedure<z.ZodObject<{
+            syncId: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
-        } | import("@casual-simulation/aux-common").GenericResult<void, import("@casual-simulation/aux-common").SimpleError>, any>;
-        search: Procedure<{
-            recordName?: string;
-            address?: string;
-            query?: z.objectOutputType<{
+        } | import("@casual-simulation/aux-common").GenericResult<void, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        search: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            query: z.ZodObject<{
                 q: z.ZodString;
                 queryBy: z.ZodString;
                 filterBy: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-            }, z.ZodUnion<[z.ZodString, z.ZodBoolean, z.ZodNumber]>, "strip">;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("@casual-simulation/aux-common").GenericResult<{
+            }, z.core.$catchall<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("@casual-simulation/aux-common").GenericResult<{
             found: number;
             outOf: number;
             page: number;
             searchTimeMs: number;
             hits: import("./search").SearchHit[];
-        }, import("@casual-simulation/aux-common").SimpleError>, any>;
-        recordDatabase: Procedure<{
-            recordName?: string;
-            item?: {
-                address?: string;
-                markers?: [string, ...string[]];
-            };
-            instances?: string[];
-        }, import("./crud").CrudRecordItemResult, any>;
-        getDatabase: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./crud").CrudGetItemResult<any>, any>;
-        eraseDatabase: Procedure<{
-            recordName?: string;
-            address?: string;
-            instances?: string[];
-        }, import("./crud").CrudEraseItemResult, any>;
-        listDatabases: Procedure<{
-            recordName?: string;
-            address?: string;
-            marker?: string;
-            sort?: "ascending" | "descending";
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<any> | {
+        }, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        recordDatabase: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            item: z.ZodNonOptional<z.ZodObject<{
+                address: z.ZodString;
+                markers: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudRecordItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getDatabase: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudGetItemResult<any>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        eraseDatabase: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudEraseItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listDatabases: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            marker: z.ZodOptional<z.ZodString>;
+            sort: z.ZodOptional<z.ZodEnum<{
+                ascending: "ascending";
+                descending: "descending";
+            }>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<any> | {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        queryDatabase: Procedure<{
-            recordName?: string;
-            address?: string;
-            statements?: {
-                query?: string;
-                params?: any[];
-            }[];
-            readonly?: boolean;
-            automaticTransaction?: boolean;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("@casual-simulation/aux-common").GenericResult<import("./database").QueryResult[], import("@casual-simulation/aux-common").SimpleError>, any>;
-        listRecords: Procedure<{
-            studioId?: string;
-            userId?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").ListRecordsSuccess | import("./RecordsController").ListRecordsFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        queryDatabase: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            statements: z.ZodArray<z.ZodObject<{
+                query: z.ZodString;
+                params: z.ZodPrefault<z.ZodOptional<z.ZodArray<z.ZodAny>>>;
+            }, z.core.$strip>>;
+            readonly: z.ZodPrefault<z.ZodBoolean>;
+            automaticTransaction: z.ZodPrefault<z.ZodOptional<z.ZodBoolean>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("@casual-simulation/aux-common").GenericResult<import("./database").QueryResult[], SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listRecords: Procedure<z.ZodObject<{
+            studioId: z.ZodOptional<z.ZodString>;
+            userId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").ListRecordsSuccess | import("./RecordsController").ListRecordsFailure | {
             readonly success: false;
             readonly errorCode: "not_authorized";
             readonly errorMessage: "You are not authorized to perform this action.";
-        }, any>;
-        createRecordKey: Procedure<{
-            recordName?: string;
-            policy?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").CreatePublicRecordKeyResult | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        createRecordKey: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            policy: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").CreatePublicRecordKeyResult | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
-        }, any>;
-        grantPermission: Procedure<{
-            recordName?: string;
-            permission?: {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "data";
-                action?: "create" | "read" | "update" | "delete" | "list";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "file";
-                action?: "create" | "read" | "update" | "delete" | "list";
-                options?: {
-                    maxFileSizeInBytes?: number;
-                    allowedMimeTypes?: true | string[];
-                };
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "event";
-                resourceId?: string;
-                action?: "update" | "increment" | "count" | "list";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "marker";
-                action?: "read" | "assign" | "unassign" | "grantPermission" | "revokePermission";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "role";
-                action?: "read" | "update" | "list" | "grant" | "revoke";
-                options?: {
-                    maxDurationMs?: number;
-                };
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "inst";
-                action?: "create" | "read" | "update" | "delete" | "list" | "sendAction" | "updateData";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "loom";
-                action?: "create";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "ai.sloyd";
-                action?: "create";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "ai.hume";
-                action?: "create";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "ai.openai.realtime";
-                action?: "create";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "webhook";
-                action?: "create" | "read" | "update" | "delete" | "list" | "run";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "notification";
-                action?: "create" | "read" | "update" | "delete" | "list" | "send" | "subscribe" | "unsubscribe" | "listSubscriptions";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "package";
-                action?: "create" | "read" | "update" | "delete" | "list" | "run";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "package.version";
-                action?: "create" | "read" | "update" | "delete" | "list" | "run";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "search";
-                action?: "create" | "read" | "update" | "delete" | "list";
-            } | {
-                marker?: string;
-                subjectType?: "inst" | "user" | "role";
-                subjectId?: string;
-                resourceId?: string;
-                expireTimeMs?: number;
-                resourceKind?: "database";
-                action?: "create" | "read" | "update" | "delete" | "list";
-            };
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").GrantMarkerPermissionSuccess | import("./PolicyController").GrantMarkerPermissionFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        grantPermission: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            permission: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"data">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    read: "read";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    list: "list";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"file">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    read: "read";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    list: "list";
+                }>>;
+                options: z.ZodObject<{
+                    maxFileSizeInBytes: z.ZodOptional<z.ZodNumber>;
+                    allowedMimeTypes: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodArray<z.ZodString>]>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"event">;
+                resourceId: z.ZodNullable<z.ZodString>;
+                action: z.ZodNullable<z.ZodEnum<{
+                    update: "update";
+                    increment: "increment";
+                    count: "count";
+                    list: "list";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"marker">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    read: "read";
+                    assign: "assign";
+                    unassign: "unassign";
+                    grantPermission: "grantPermission";
+                    revokePermission: "revokePermission";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"role">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    read: "read";
+                    update: "update";
+                    list: "list";
+                    grant: "grant";
+                    revoke: "revoke";
+                }>>;
+                options: z.ZodObject<{
+                    maxDurationMs: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"inst">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    read: "read";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    list: "list";
+                    sendAction: "sendAction";
+                    updateData: "updateData";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"loom">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    create: "create";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"ai.sloyd">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    create: "create";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"ai.hume">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    create: "create";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"ai.openai.realtime">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    create: "create";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"webhook">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    run: "run";
+                    read: "read";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    list: "list";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"notification">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    read: "read";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    list: "list";
+                    send: "send";
+                    subscribe: "subscribe";
+                    unsubscribe: "unsubscribe";
+                    listSubscriptions: "listSubscriptions";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"package">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    run: "run";
+                    read: "read";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    list: "list";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"package.version">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    run: "run";
+                    read: "read";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    list: "list";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"search">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    read: "read";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    list: "list";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"database">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    read: "read";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    list: "list";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"purchasableItem">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    read: "read";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    list: "list";
+                    purchase: "purchase";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"contract">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    read: "read";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    list: "list";
+                    purchase: "purchase";
+                    cancel: "cancel";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                subjectType: z.ZodEnum<{
+                    inst: "inst";
+                    user: "user";
+                    role: "role";
+                }>;
+                subjectId: z.ZodString;
+                resourceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                expireTimeMs: z.ZodNullable<z.ZodNumber>;
+                marker: z.ZodOptional<z.ZodString>;
+                resourceKind: z.ZodLiteral<"invoice">;
+                action: z.ZodNullable<z.ZodEnum<{
+                    read: "read";
+                    create: "create";
+                    update: "update";
+                    delete: "delete";
+                    list: "list";
+                    approve: "approve";
+                    cancel: "cancel";
+                }>>;
+            }, z.core.$strip>], "resourceKind">;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").GrantMarkerPermissionSuccess | import("./PolicyController").GrantMarkerPermissionFailure | {
             readonly success: false;
             readonly errorCode: "unacceptable_request";
             readonly errorMessage: "The given permission must have either a marker or a resourceId.";
-        }, any>;
-        revokePermission: Procedure<{
-            permissionId?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").RevokePermissionResult, any>;
-        listPermissions: Procedure<{
-            recordName?: string;
-            marker?: string;
-            resourceKind?: "search" | "data" | "role" | "event" | "inst" | "file" | "marker" | "loom" | "ai.sloyd" | "ai.hume" | "ai.openai.realtime" | "webhook" | "notification" | "package" | "package.version" | "database";
-            resourceId?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").ListPermissionsFailure | import("./PolicyController").ListPermissionsForMarkerSuccess | import("./PolicyController").ListPermissionsForResourceSuccess, any>;
-        listUserRoles: Procedure<{
-            recordName?: string;
-            userId?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").ListAssignedUserRolesResult, any>;
-        listInstRoles: Procedure<{
-            recordName?: string;
-            inst?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").ListAssignedInstRolesResult, any>;
-        listRoleAssignments: Procedure<{
-            recordName?: string;
-            startingRole?: string;
-            role?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").ListRoleAssignmentsResult, any>;
-        grantRole: Procedure<{
-            recordName?: string;
-            userId?: string;
-            inst?: string;
-            role?: string;
-            expireTimeMs?: number;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").GrantRoleResult, any>;
-        revokeRole: Procedure<{
-            recordName?: string;
-            userId?: string;
-            inst?: string;
-            role?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").RevokeRoleResult, any>;
-        grantEntitlement: Procedure<{
-            packageId?: string;
-            userId?: string;
-            recordName?: string;
-            feature?: "search" | "data" | "event" | "inst" | "file" | "webhook" | "notification" | "package" | "database" | "permissions" | "ai";
-            scope?: "designated";
-            expireTimeMs?: number;
-        }, import("./PolicyController").GrantEntitlementResult, any>;
-        revokeEntitlement: Procedure<{
-            grantId?: string;
-        }, import("./PolicyController").RevokeEntitlementResult, any>;
-        listGrantedEntitlements: Procedure<{
-            packageId?: string;
-        }, import("./PolicyController").ListGrantedEntitlementsResult, any>;
-        aiChat: Procedure<{
-            model?: string;
-            messages?: [{
-                role?: "function" | "system" | "user" | "assistant";
-                content?: string | ({
-                    text?: string;
-                } | {
-                    base64?: string;
-                    mimeType?: string;
-                } | {
-                    url?: string;
-                })[];
-                author?: string;
-            }, ...{
-                role?: "function" | "system" | "user" | "assistant";
-                content?: string | ({
-                    text?: string;
-                } | {
-                    base64?: string;
-                    mimeType?: string;
-                } | {
-                    url?: string;
-                })[];
-                author?: string;
-            }[]];
-            instances?: string[];
-            temperature?: number;
-            topP?: number;
-            presencePenalty?: number;
-            frequencyPenalty?: number;
-            stopWords?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./AIController").AIChatResponse | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        revokePermission: Procedure<z.ZodObject<{
+            permissionId: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").RevokePermissionResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listPermissions: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            marker: z.ZodOptional<z.ZodString>;
+            resourceKind: z.ZodOptional<z.ZodEnum<{
+                search: "search";
+                inst: "inst";
+                file: "file";
+                event: "event";
+                role: "role";
+                data: "data";
+                marker: "marker";
+                loom: "loom";
+                "ai.sloyd": "ai.sloyd";
+                "ai.hume": "ai.hume";
+                "ai.openai.realtime": "ai.openai.realtime";
+                webhook: "webhook";
+                notification: "notification";
+                package: "package";
+                "package.version": "package.version";
+                database: "database";
+                purchasableItem: "purchasableItem";
+                contract: "contract";
+                invoice: "invoice";
+            }>>;
+            resourceId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").ListPermissionsFailure | import("./PolicyController").ListPermissionsForMarkerSuccess | import("./PolicyController").ListPermissionsForResourceSuccess, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listUserRoles: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            userId: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").ListAssignedUserRolesResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listInstRoles: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            inst: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").ListAssignedInstRolesResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listRoleAssignments: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            startingRole: z.ZodOptional<z.ZodString>;
+            role: z.ZodOptional<z.ZodString>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").ListRoleAssignmentsResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        grantRole: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            userId: z.ZodOptional<z.ZodString>;
+            inst: z.ZodOptional<z.ZodString>;
+            role: z.ZodString;
+            expireTimeMs: z.ZodOptional<z.ZodNumber>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").GrantRoleResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        revokeRole: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            userId: z.ZodOptional<z.ZodString>;
+            inst: z.ZodOptional<z.ZodString>;
+            role: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").RevokeRoleResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        grantEntitlement: Procedure<z.ZodObject<{
+            packageId: z.ZodString;
+            userId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            recordName: z.ZodString;
+            feature: z.ZodEnum<{
+                search: "search";
+                inst: "inst";
+                file: "file";
+                event: "event";
+                data: "data";
+                webhook: "webhook";
+                notification: "notification";
+                package: "package";
+                database: "database";
+                permissions: "permissions";
+                ai: "ai";
+            }>;
+            scope: z.ZodLiteral<"designated">;
+            expireTimeMs: z.ZodNumber;
+        }, z.core.$strip>, import("./PolicyController").GrantEntitlementResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        revokeEntitlement: Procedure<z.ZodObject<{
+            grantId: z.ZodString;
+        }, z.core.$strip>, import("./PolicyController").RevokeEntitlementResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listGrantedEntitlements: Procedure<z.ZodObject<{
+            packageId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>, import("./PolicyController").ListGrantedEntitlementsResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        aiChat: Procedure<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            messages: z.ZodArray<z.ZodObject<{
+                role: z.ZodUnion<readonly [z.ZodLiteral<"system">, z.ZodLiteral<"user">, z.ZodLiteral<"assistant">, z.ZodLiteral<"function">]>;
+                content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    text: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    base64: z.ZodString;
+                    mimeType: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    url: z.ZodURL;
+                }, z.core.$strip>]>>]>;
+                author: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            presencePenalty: z.ZodOptional<z.ZodNumber>;
+            frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+            stopWords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./AIController").AIChatResponse | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -1356,39 +1737,28 @@ export declare class RecordsServer {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        aiChatStream: Procedure<{
-            model?: string;
-            messages?: [{
-                role?: "function" | "system" | "user" | "assistant";
-                content?: string | ({
-                    text?: string;
-                } | {
-                    base64?: string;
-                    mimeType?: string;
-                } | {
-                    url?: string;
-                })[];
-                author?: string;
-            }, ...{
-                role?: "function" | "system" | "user" | "assistant";
-                content?: string | ({
-                    text?: string;
-                } | {
-                    base64?: string;
-                    mimeType?: string;
-                } | {
-                    url?: string;
-                })[];
-                author?: string;
-            }[]];
-            instances?: string[];
-            temperature?: number;
-            topP?: number;
-            presencePenalty?: number;
-            frequencyPenalty?: number;
-            stopWords?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | AsyncGenerator<Pick<import("./AIChatInterface").AIChatInterfaceStreamResponse, "choices">, import("./AIController").AIChatStreamResponse, any> | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        aiChatStream: Procedure<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            messages: z.ZodArray<z.ZodObject<{
+                role: z.ZodUnion<readonly [z.ZodLiteral<"system">, z.ZodLiteral<"user">, z.ZodLiteral<"assistant">, z.ZodLiteral<"function">]>;
+                content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    text: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    base64: z.ZodString;
+                    mimeType: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    url: z.ZodURL;
+                }, z.core.$strip>]>>]>;
+                author: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            topP: z.ZodOptional<z.ZodNumber>;
+            presencePenalty: z.ZodOptional<z.ZodNumber>;
+            frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+            stopWords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | AsyncGenerator<Pick<import("./AIChatInterface").AIChatInterfaceStreamResponse, "choices">, import("./AIController").AIChatStreamResponse, any> | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -1396,8 +1766,8 @@ export declare class RecordsServer {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        aiListChatModels: Procedure<{}, import("./AuthController").ValidateSessionKeyFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        aiListChatModels: Procedure<z.ZodObject<{}, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -1405,17 +1775,17 @@ export declare class RecordsServer {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        } | import("@casual-simulation/aux-common").GenericResult<import("./AIController").ListedChatModel[], import("@casual-simulation/aux-common").SimpleError>, any>;
-        createAiSkybox: Procedure<{
-            prompt?: string;
-            negativePrompt?: string;
-            blockadeLabs?: {
-                skyboxStyleId?: number;
-                remixImagineId?: number;
-                seed?: number;
-            };
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./AIController").AIGenerateSkyboxResponse | {
+        } | import("@casual-simulation/aux-common").GenericResult<import("./AIController").ListedChatModel[], SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        createAiSkybox: Procedure<z.ZodObject<{
+            prompt: z.ZodString;
+            negativePrompt: z.ZodOptional<z.ZodString>;
+            blockadeLabs: z.ZodOptional<z.ZodObject<{
+                skyboxStyleId: z.ZodOptional<z.ZodNumber>;
+                remixImagineId: z.ZodOptional<z.ZodNumber>;
+                seed: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./AIController").AIGenerateSkyboxResponse | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -1423,11 +1793,11 @@ export declare class RecordsServer {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        getAiSkybox: Procedure<{
-            skyboxId?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./AIController").AIGetSkyboxResponse | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getAiSkybox: Procedure<z.ZodObject<{
+            skyboxId: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./AIController").AIGetSkyboxResponse | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -1435,22 +1805,22 @@ export declare class RecordsServer {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        createAiImage: Procedure<{
-            prompt?: string;
-            model?: string;
-            negativePrompt?: string;
-            width?: number;
-            height?: number;
-            seed?: number;
-            numberOfImages?: number;
-            steps?: number;
-            sampler?: string;
-            cfgScale?: number;
-            clipGuidancePreset?: string;
-            stylePreset?: string;
-            instances?: string[];
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./AIController").AIGenerateImageResponse | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        createAiImage: Procedure<z.ZodObject<{
+            prompt: z.ZodString;
+            model: z.ZodOptional<z.ZodString>;
+            negativePrompt: z.ZodOptional<z.ZodString>;
+            width: z.ZodOptional<z.ZodInt>;
+            height: z.ZodOptional<z.ZodInt>;
+            seed: z.ZodOptional<z.ZodInt>;
+            numberOfImages: z.ZodOptional<z.ZodInt>;
+            steps: z.ZodOptional<z.ZodInt>;
+            sampler: z.ZodOptional<z.ZodString>;
+            cfgScale: z.ZodOptional<z.ZodInt>;
+            clipGuidancePreset: z.ZodOptional<z.ZodString>;
+            stylePreset: z.ZodOptional<z.ZodString>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./AIController").AIGenerateImageResponse | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -1458,22 +1828,25 @@ export declare class RecordsServer {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        getHumeAccessToken: Procedure<{
-            recordName?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./AIController").AIHumeGetAccessTokenResult, any>;
-        createSloydModel: Procedure<{
-            recordName?: string;
-            outputMimeType?: "model/gltf+json" | "model/gltf-binary";
-            prompt?: string;
-            levelOfDetail?: number;
-            baseModelId?: string;
-            thumbnail?: {
-                type?: "image/png";
-                width?: number;
-                height?: number;
-            };
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./AIController").AISloydGenerateModelResponse | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getHumeAccessToken: Procedure<z.ZodObject<{
+            recordName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./AIController").AIHumeGetAccessTokenResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        createSloydModel: Procedure<z.ZodObject<{
+            recordName: z.ZodOptional<z.ZodString>;
+            outputMimeType: z.ZodPrefault<z.ZodEnum<{
+                "model/gltf+json": "model/gltf+json";
+                "model/gltf-binary": "model/gltf-binary";
+            }>>;
+            prompt: z.ZodString;
+            levelOfDetail: z.ZodOptional<z.ZodNumber>;
+            baseModelId: z.ZodOptional<z.ZodString>;
+            thumbnail: z.ZodOptional<z.ZodObject<{
+                type: z.ZodLiteral<"image/png">;
+                width: z.ZodInt;
+                height: z.ZodInt;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./AIController").AISloydGenerateModelResponse | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -1481,10 +1854,10 @@ export declare class RecordsServer {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        getLoomAccessToken: Procedure<{
-            recordName?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./LoomController").LoomGetTokenResult | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getLoomAccessToken: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./LoomController").LoomGetTokenResult | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -1492,125 +1865,293 @@ export declare class RecordsServer {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        createOpenAIRealtimeSession: Procedure<{
-            recordName?: string;
-            request?: {
-                model?: string;
-                instructions?: string;
-                modalities?: ("text" | "audio")[];
-                maxResponseOutputTokens?: number;
-                inputAudioFormat?: "pcm16" | "g711_ulaw" | "g711_alaw";
-                inputAudioNoiseReduction?: {
-                    type?: "near_field" | "far_field";
-                };
-                inputAudioTranscription?: {
-                    language?: string;
-                    model?: string;
-                    prompt?: string;
-                };
-                outputAudioFormat?: "pcm16" | "g711_ulaw" | "g711_alaw";
-                temperature?: number;
-                toolChoice?: string;
-                tools?: {
-                    description?: string;
-                    name?: string;
-                    parameters?: any;
-                    type?: "function";
-                }[];
-                turnDetection?: {
-                    createResponse?: boolean;
-                    eagerness?: "low" | "medium" | "high";
-                    interruptResponse?: boolean;
-                    prefixPaddingMs?: number;
-                    silenceDurationMs?: number;
-                    threshold?: number;
-                    type?: "server_vad" | "semantic_vad";
-                };
-                voice?: string;
-            };
-        }, import("./AIController").AICreateOpenAIRealtimeSessionTokenResult, any>;
-        getStudio: Procedure<{
-            studioId?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").GetStudioResult, any>;
-        createStudio: Procedure<{
-            displayName?: string;
-            ownerStudioComId?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").CreateStudioSuccess | import("./RecordsController").CreateStudioInComIdFailure, any>;
-        updateStudio: Procedure<{
-            id?: string;
-            displayName?: string;
-            logoUrl?: string;
-            logoBackgroundColor?: string;
-            comIdConfig?: {
-                allowedStudioCreators?: "anyone" | "only-members";
-            };
-            playerConfig?: {
-                ab1BootstrapURL?: string;
-                arcGisApiKey?: string;
-                jitsiAppName?: string;
-                what3WordsApiKey?: string;
-                allowedBiosOptions?: ("studio" | "enter join code" | "join inst" | "static inst" | "local inst" | "local" | "public inst" | "private inst" | "free inst" | "free" | "studio inst" | "sign in" | "sign up" | "sign out" | "delete inst")[];
-                defaultBiosOption?: "studio" | "enter join code" | "join inst" | "static inst" | "local inst" | "local" | "public inst" | "private inst" | "free inst" | "free" | "studio inst" | "sign in" | "sign up" | "sign out" | "delete inst";
-                automaticBiosOption?: "studio" | "enter join code" | "join inst" | "static inst" | "local inst" | "local" | "public inst" | "private inst" | "free inst" | "free" | "studio inst" | "sign in" | "sign up" | "sign out" | "delete inst";
-                logoBackgroundColor?: string;
-            };
-            loomConfig?: {
-                appId?: string;
-                privateKey?: string;
-            };
-            humeConfig?: {
-                apiKey?: string;
-                secretKey?: string;
-            };
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").UpdateStudioResult, any>;
-        requestStudioComId: Procedure<{
-            studioId?: string;
-            comId?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").ComIdRequestResult | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        createOpenAIRealtimeSession: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            request: z.ZodObject<{
+                model: z.ZodString;
+                instructions: z.ZodOptional<z.ZodString>;
+                modalities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    audio: "audio";
+                    text: "text";
+                }>>>;
+                maxResponseOutputTokens: z.ZodOptional<z.ZodInt>;
+                inputAudioFormat: z.ZodOptional<z.ZodEnum<{
+                    pcm16: "pcm16";
+                    g711_ulaw: "g711_ulaw";
+                    g711_alaw: "g711_alaw";
+                }>>;
+                inputAudioNoiseReduction: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+                    type: z.ZodOptional<z.ZodEnum<{
+                        near_field: "near_field";
+                        far_field: "far_field";
+                    }>>;
+                }, z.core.$strip>>>;
+                inputAudioTranscription: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+                    language: z.ZodOptional<z.ZodString>;
+                    model: z.ZodOptional<z.ZodString>;
+                    prompt: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+                outputAudioFormat: z.ZodOptional<z.ZodEnum<{
+                    pcm16: "pcm16";
+                    g711_ulaw: "g711_ulaw";
+                    g711_alaw: "g711_alaw";
+                }>>;
+                temperature: z.ZodOptional<z.ZodNumber>;
+                toolChoice: z.ZodOptional<z.ZodString>;
+                tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    description: z.ZodOptional<z.ZodString>;
+                    name: z.ZodString;
+                    parameters: z.ZodOptional<z.ZodAny>;
+                    type: z.ZodOptional<z.ZodEnum<{
+                        function: "function";
+                    }>>;
+                }, z.core.$strip>>>;
+                turnDetection: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+                    createResponse: z.ZodOptional<z.ZodBoolean>;
+                    eagerness: z.ZodOptional<z.ZodEnum<{
+                        high: "high";
+                        low: "low";
+                        medium: "medium";
+                    }>>;
+                    interruptResponse: z.ZodOptional<z.ZodBoolean>;
+                    prefixPaddingMs: z.ZodOptional<z.ZodNumber>;
+                    silenceDurationMs: z.ZodOptional<z.ZodNumber>;
+                    threshold: z.ZodOptional<z.ZodNumber>;
+                    type: z.ZodOptional<z.ZodEnum<{
+                        server_vad: "server_vad";
+                        semantic_vad: "semantic_vad";
+                    }>>;
+                }, z.core.$strip>>>;
+                voice: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, import("./AIController").AICreateOpenAIRealtimeSessionTokenResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getStudio: Procedure<z.ZodObject<{
+            studioId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").GetStudioResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        createStudio: Procedure<z.ZodObject<{
+            displayName: z.ZodString;
+            ownerStudioComId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").CreateStudioSuccess | import("./RecordsController").CreateStudioInComIdFailure, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        updateStudio: Procedure<z.ZodObject<{
+            id: z.ZodString;
+            displayName: z.ZodOptional<z.ZodString>;
+            logoUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+            logoBackgroundColor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            comIdConfig: z.ZodOptional<z.ZodObject<{
+                allowedStudioCreators: z.ZodUnion<readonly [z.ZodLiteral<"anyone">, z.ZodLiteral<"only-members">]>;
+            }, z.core.$strip>>;
+            playerConfig: z.ZodOptional<z.ZodObject<{
+                disableVM: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>>;
+                ab1BootstrapURL: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+                arcGisApiKey: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+                jitsiAppName: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+                what3WordsApiKey: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+                allowedBiosOptions: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
+                    local: "local";
+                    studio: "studio";
+                    locked: "locked";
+                    "enter join code": "enter join code";
+                    "join inst": "join inst";
+                    temp: "temp";
+                    "static inst": "static inst";
+                    "local inst": "local inst";
+                    "public inst": "public inst";
+                    "free inst": "free inst";
+                    free: "free";
+                    "private inst": "private inst";
+                    "studio inst": "studio inst";
+                    "sign in": "sign in";
+                    "sign up": "sign up";
+                    "sign out": "sign out";
+                    "delete inst": "delete inst";
+                }>>>>>;
+                defaultBiosOption: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    local: "local";
+                    studio: "studio";
+                    locked: "locked";
+                    "enter join code": "enter join code";
+                    "join inst": "join inst";
+                    temp: "temp";
+                    "static inst": "static inst";
+                    "local inst": "local inst";
+                    "public inst": "public inst";
+                    "free inst": "free inst";
+                    free: "free";
+                    "private inst": "private inst";
+                    "studio inst": "studio inst";
+                    "sign in": "sign in";
+                    "sign up": "sign up";
+                    "sign out": "sign out";
+                    "delete inst": "delete inst";
+                }>>>>;
+                automaticBiosOption: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    local: "local";
+                    studio: "studio";
+                    locked: "locked";
+                    "enter join code": "enter join code";
+                    "join inst": "join inst";
+                    temp: "temp";
+                    "static inst": "static inst";
+                    "local inst": "local inst";
+                    "public inst": "public inst";
+                    "free inst": "free inst";
+                    free: "free";
+                    "private inst": "private inst";
+                    "studio inst": "studio inst";
+                    "sign in": "sign in";
+                    "sign up": "sign up";
+                    "sign out": "sign out";
+                    "delete inst": "delete inst";
+                }>>>>;
+                automaticBiosOptionInst: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+                logoBackgroundColor: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+            }, z.core.$strip>>;
+            loomConfig: z.ZodOptional<z.ZodObject<{
+                appId: z.ZodString;
+                privateKey: z.ZodString;
+            }, z.core.$strip>>;
+            humeConfig: z.ZodOptional<z.ZodObject<{
+                apiKey: z.ZodString;
+                secretKey: z.ZodString;
+            }, z.core.$strip>>;
+            playerWebManifest: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                short_name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                start_url: z.ZodPrefault<z.ZodString>;
+                display: z.ZodPrefault<z.ZodEnum<{
+                    fullscreen: "fullscreen";
+                    standalone: "standalone";
+                    "minimal-ui": "minimal-ui";
+                    browser: "browser";
+                }>>;
+                background_color: z.ZodPrefault<z.ZodString>;
+                theme_color: z.ZodPrefault<z.ZodString>;
+                icons: z.ZodPrefault<z.ZodArray<z.ZodObject<{
+                    src: z.ZodString;
+                    type: z.ZodString;
+                    sizes: z.ZodUnion<readonly [z.ZodLiteral<"any">, z.ZodString]>;
+                    purpose: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$loose>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").UpdateStudioResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        addCustomDomain: Procedure<z.ZodObject<{
+            studioId: z.ZodString;
+            domain: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | import("@casual-simulation/aux-common").GenericResult<import("./dns").DomainNameVerificationDNSRecord, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        deleteCustomDomain: Procedure<z.ZodObject<{
+            customDomainId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | import("@casual-simulation/aux-common").GenericResult<void, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listCustomDomains: Procedure<z.ZodObject<{
+            studioId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | import("@casual-simulation/aux-common").GenericResult<{
+            domains: import("./RecordsStore").ListedCustomDomain[];
+        }, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        verifyCustomDomain: Procedure<z.ZodObject<{
+            customDomainId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
-        }, any>;
-        listStudios: Procedure<{
-            comId?: string;
-            userId?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").ListStudiosSuccess | import("./RecordsController").ListStudiosFailure | {
+        } | import("@casual-simulation/aux-common").GenericResult<void, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        requestStudioComId: Procedure<z.ZodObject<{
+            studioId: z.ZodString;
+            comId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").ComIdRequestResult | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listStudios: Procedure<z.ZodObject<{
+            comId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            userId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").ListStudiosSuccess | import("./RecordsController").ListStudiosFailure | {
             readonly success: false;
             readonly errorCode: "not_authorized";
             readonly errorMessage: "You are not authorized to perform this action.";
-        }, any>;
-        listStudioMembers: Procedure<{
-            studioId?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").ListStudioMembersResult, any>;
-        addStudioMember: Procedure<{
-            studioId?: string;
-            addedUserId?: string;
-            addedEmail?: string;
-            addedPhoneNumber?: string;
-            addedDisplayName?: string;
-            role?: "admin" | "member";
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").AddStudioMemberResult, any>;
-        removeStudioMember: Procedure<{
-            studioId?: string;
-            removedUserId?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").RemoveStudioMemberResult, any>;
-        getPlayerConfig: Procedure<{
-            comId?: string;
-        }, import("./RecordsController").GetPlayerConfigResult, any>;
-        getSubscriptions: Procedure<{
-            studioId?: string;
-            userId?: string;
-        }, import("./SubscriptionController").GetSubscriptionStatusSuccess | import("./SubscriptionController").GetSubscriptionStatusFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listStudioMembers: Procedure<z.ZodObject<{
+            studioId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").ListStudioMembersResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        addStudioMember: Procedure<z.ZodObject<{
+            studioId: z.ZodString;
+            addedUserId: z.ZodOptional<z.ZodString>;
+            addedEmail: z.ZodOptional<z.ZodString>;
+            addedPhoneNumber: z.ZodOptional<z.ZodString>;
+            addedDisplayName: z.ZodOptional<z.ZodString>;
+            role: z.ZodUnion<readonly [z.ZodLiteral<"admin">, z.ZodLiteral<"member">]>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").AddStudioMemberResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        removeStudioMember: Procedure<z.ZodObject<{
+            studioId: z.ZodString;
+            removedUserId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").RemoveStudioMemberResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getManageStudioStoreLink: Procedure<z.ZodObject<{
+            studioId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
         } | {
+            success: false;
+            errorCode: "not_supported";
+            errorMessage: string;
+        } | import("@casual-simulation/aux-common").GenericResult<{
+            url: string;
+        }, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getWebConfig: Procedure<z.ZodObject<{}, z.core.$strip>, import("@casual-simulation/aux-common").GenericResult<import("@casual-simulation/aux-common").CasualOSConfig, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getPlayerWebManifest: Procedure<z.ZodObject<{}, z.core.$strip>, import("@casual-simulation/aux-common").GenericResult<{
+            [x: string]: unknown;
+            name: string;
+            short_name: string;
+            start_url: string;
+            display: "fullscreen" | "browser" | "standalone" | "minimal-ui";
+            background_color: string;
+            theme_color: string;
+            icons: {
+                src: string;
+                type: string;
+                sizes?: string;
+                purpose?: string;
+            }[];
+            description?: string;
+        }, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getPlayerConfig: Procedure<z.ZodObject<{
+            comId: z.ZodString;
+        }, z.core.$strip>, import("./RecordsController").GetPlayerConfigResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getBalances: Procedure<z.ZodObject<{
+            studioId: z.ZodOptional<z.ZodString>;
+            contractId: z.ZodOptional<z.ZodString>;
+            userId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | {
+            success: false;
+            errorCode: "not_supported";
+            errorMessage: string;
+        } | import("@casual-simulation/aux-common").GenericResult<{
+            usd: import("@casual-simulation/aux-common").JSONAccountBalance;
+            credits: import("@casual-simulation/aux-common").JSONAccountBalance;
+        }, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getSubscriptions: Procedure<z.ZodObject<{
+            studioId: z.ZodOptional<z.ZodString>;
+            userId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./SubscriptionController").GetSubscriptionStatusSuccess | import("./SubscriptionController").GetSubscriptionStatusFailure | {
             readonly success: true;
             readonly publishableKey: string;
             readonly subscriptions: {
                 active: boolean;
-                statusCode: "incomplete" | "active" | "trialing" | "canceled" | "ended" | "past_due" | "unpaid" | "incomplete_expired" | "paused";
+                statusCode: "unpaid" | "active" | "canceled" | "ended" | "past_due" | "incomplete" | "incomplete_expired" | "trialing" | "paused";
                 productName: string;
                 startDate: number;
                 endedDate: number;
@@ -1618,7 +2159,7 @@ export declare class RecordsServer {
                 canceledDate: number;
                 currentPeriodStart: number;
                 currentPeriodEnd: number;
-                renewalInterval: "year" | "month" | "day" | "week";
+                renewalInterval: "month" | "year" | "week" | "day";
                 intervalLength: number;
                 intervalCost: number;
                 currency: string;
@@ -1638,39 +2179,54 @@ export declare class RecordsServer {
                 }[];
                 defaultSubscription: boolean;
             }[];
-        }, any>;
-        getManageSubscriptionLink: Procedure<{
-            userId?: string;
-            studioId?: string;
-            subscriptionId?: string;
-            expectedPrice?: {
-                currency?: string;
-                cost?: number;
-                interval?: "year" | "month" | "day" | "week";
-                intervalLength?: number;
+            readonly accountBalances: {
+                usd: import("@casual-simulation/aux-common").JSONAccountBalance;
+                credits: import("@casual-simulation/aux-common").JSONAccountBalance;
             };
-        }, import("./SubscriptionController").CreateManageSubscriptionResult | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getManageSubscriptionLink: Procedure<z.ZodObject<{
+            userId: z.ZodOptional<z.ZodString>;
+            studioId: z.ZodOptional<z.ZodString>;
+            subscriptionId: z.ZodOptional<z.ZodString>;
+            expectedPrice: z.ZodOptional<z.ZodObject<{
+                currency: z.ZodString;
+                cost: z.ZodNumber;
+                interval: z.ZodEnum<{
+                    month: "month";
+                    year: "year";
+                    week: "week";
+                    day: "day";
+                }>;
+                intervalLength: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./SubscriptionController").CreateManageSubscriptionResult | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
-        }, any>;
-        updateSubscription: Procedure<{
-            userId?: string;
-            studioId?: string;
-            subscriptionId?: string;
-            subscriptionStatus?: "incomplete" | "active" | "trialing" | "canceled" | "ended" | "past_due" | "unpaid" | "incomplete_expired" | "paused";
-            subscriptionPeriodStartMs?: number;
-            subscriptionPeriodEndMs?: number;
-        }, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | import("./SubscriptionController").UpdateSubscriptionResult | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        updateSubscription: Procedure<z.ZodObject<{
+            userId: z.ZodOptional<z.ZodString>;
+            studioId: z.ZodOptional<z.ZodString>;
+            subscriptionId: z.ZodNullable<z.ZodString>;
+            subscriptionStatus: z.ZodNullable<z.ZodEnum<{
+                unpaid: "unpaid";
+                active: "active";
+                canceled: "canceled";
+                ended: "ended";
+                past_due: "past_due";
+                incomplete: "incomplete";
+                incomplete_expired: "incomplete_expired";
+                trialing: "trialing";
+                paused: "paused";
+            }>>;
+            subscriptionPeriodStartMs: z.ZodNullable<z.ZodInt>;
+            subscriptionPeriodEndMs: z.ZodNullable<z.ZodInt>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | import("./SubscriptionController").UpdateSubscriptionResult | {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        listInsts: Procedure<{
-            recordName?: string;
-            inst?: string;
-            marker?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | import("./websockets/WebsocketController").ListInstsResult | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getManageXpAccountLink: Procedure<z.ZodObject<{}, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -1678,12 +2234,12 @@ export declare class RecordsServer {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        deleteInst: Procedure<{
-            recordKey?: string;
-            recordName?: string;
-            inst?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | import("./websockets/WebsocketController").EraseInstResult | {
+        } | import("@casual-simulation/aux-common").GenericResult<{
+            url: string;
+        }, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getStripeLoginLink: Procedure<z.ZodObject<{
+            studioId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | {
             success: false;
             errorCode: "not_logged_in";
             errorMessage: "The user is not logged in. A session key must be provided for this operation.";
@@ -1691,41 +2247,296 @@ export declare class RecordsServer {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        reportInst: Procedure<{
-            recordName?: string;
-            inst?: string;
-            automaticReport?: boolean;
-            reportReason?: "other" | "poor-performance" | "spam" | "harassment" | "copyright-infringement" | "obscene" | "illegal";
-            reportReasonText?: string;
-            reportedUrl?: string;
-            reportedPermalink?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | import("./ModerationController").ReportInstResult | {
+        } | import("@casual-simulation/aux-common").GenericResult<{
+            url: string;
+        }, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        recordContract: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            item: z.ZodNonOptional<z.ZodObject<{
+                address: z.ZodString;
+                holdingUser: z.ZodString;
+                rate: z.ZodInt;
+                initialValue: z.ZodInt;
+                description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                markers: z.ZodPrefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudRecordItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getContract: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudGetItemResult<any>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listContracts: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            marker: z.ZodOptional<z.ZodString>;
+            sort: z.ZodOptional<z.ZodEnum<{
+                ascending: "ascending";
+                descending: "descending";
+            }>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./crud").CrudListItemsFailure | import("./crud").CrudListItemsSuccess<any> | {
             success: false;
             errorCode: "not_supported";
             errorMessage: string;
-        }, any>;
-        getInstData: Procedure<{
-            recordName?: string;
-            inst?: string;
-            branch?: string;
-        }, import("./AuthController").ValidateSessionKeyFailure | {
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        eraseContract: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudEraseItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        cancelContract: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | {
             success: false;
-            errorCode: import("@casual-simulation/aux-common").ServerError | "inst_not_found" | import("./PolicyController").ConstructAuthorizationContextFailure["errorCode"] | import("./PolicyController").AuthorizeSubjectFailure["errorCode"] | import("./websockets/WebsocketController").GetOrCreateInstFailure["errorCode"];
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | {
+            success: false;
+            errorCode: "not_supported";
             errorMessage: string;
-            reason?: DenialReason;
+        } | import("@casual-simulation/aux-common").GenericResult<{
+            refundedAmount: number;
+            refundCurrency: string;
+        }, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listInsts: Procedure<z.ZodObject<{
+            recordName: z.ZodOptional<z.ZodString>;
+            inst: z.ZodOptional<z.ZodString>;
+            marker: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | import("./websockets/WebsocketController").ListInstsResult | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | {
+            success: false;
+            errorCode: "not_supported";
+            errorMessage: string;
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        invoiceContract: Procedure<z.ZodObject<{
+            contractId: z.ZodString;
+            amount: z.ZodInt;
+            note: z.ZodOptional<z.ZodString>;
+            payoutDestination: z.ZodEnum<{
+                account: "account";
+                stripe: "stripe";
+            }>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
         } | {
+            success: false;
+            errorCode: "not_supported";
+            errorMessage: string;
+        } | import("@casual-simulation/aux-common").GenericResult<{
+            invoiceId: string;
+        }, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        payContractInvoice: Procedure<z.ZodObject<{
+            invoiceId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | {
+            success: false;
+            errorCode: "not_supported";
+            errorMessage: string;
+        } | import("@casual-simulation/aux-common").GenericResult<void, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        payoutAccount: Procedure<z.ZodObject<{
+            userId: z.ZodOptional<z.ZodString>;
+            studioId: z.ZodOptional<z.ZodString>;
+            amount: z.ZodOptional<z.ZodInt>;
+            destination: z.ZodEnum<{
+                stripe: "stripe";
+                cash: "cash";
+            }>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | {
+            success: false;
+            errorCode: "not_supported";
+            errorMessage: string;
+        } | import("@casual-simulation/aux-common").GenericResult<{
+            payoutId: string;
+        }, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listContractInvoices: Procedure<z.ZodObject<{
+            contractId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | {
+            success: false;
+            errorCode: "not_supported";
+            errorMessage: string;
+        } | import("@casual-simulation/aux-common").GenericResult<import("./contracts").ContractInvoice[], SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        cancelInvoice: Procedure<z.ZodObject<{
+            invoiceId: z.ZodString;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | {
+            success: false;
+            errorCode: "not_supported";
+            errorMessage: string;
+        } | import("@casual-simulation/aux-common").GenericResult<void, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        deleteInst: Procedure<z.ZodObject<{
+            recordKey: z.ZodOptional<z.ZodString>;
+            recordName: z.ZodOptional<z.ZodString>;
+            inst: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | NoSessionKeyResult | import("./websockets/WebsocketController").EraseInstResult | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | {
+            success: false;
+            errorCode: "not_supported";
+            errorMessage: string;
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        reportInst: Procedure<z.ZodObject<{
+            recordName: z.ZodNullable<z.ZodString>;
+            inst: z.ZodString;
+            automaticReport: z.ZodBoolean;
+            reportReason: z.ZodUnion<readonly [z.ZodLiteral<"poor-performance">, z.ZodLiteral<"spam">, z.ZodLiteral<"harassment">, z.ZodLiteral<"copyright-infringement">, z.ZodLiteral<"obscene">, z.ZodLiteral<"illegal">, z.ZodLiteral<"other">]>;
+            reportReasonText: z.ZodString;
+            reportedUrl: z.ZodURL;
+            reportedPermalink: z.ZodURL;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./ModerationController").ReportInstResult | {
+            success: false;
+            errorCode: "not_supported";
+            errorMessage: string;
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getInstData: Procedure<z.ZodObject<{
+            recordName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            inst: z.ZodString;
+            branch: z.ZodPrefault<z.ZodString>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
             success: true;
             data: import("@casual-simulation/aux-common").StoredAux;
-        }, any>;
-        listProcedures: Procedure<{}, {
+        } | {
+            success: false;
+            errorCode: import("@casual-simulation/aux-common").ServerError | "inst_not_found" | import("./PolicyController").ConstructAuthorizationContextFailure["errorCode"] | import("./PolicyController").AuthorizeSubjectFailure["errorCode"] | import("./websockets/WebsocketController").GetOrCreateInstFailure["errorCode"];
+            errorMessage: string;
+            reason?: DenialReason;
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listProcedures: Procedure<z.ZodObject<{}, z.core.$strip>, {
             version: string;
             versionHash: string;
             procedures: import("@casual-simulation/aux-common").ProcedureMetadata[];
             success: true;
-        }, any>;
+        }, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getPurchasableItem: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudGetItemResult<PurchasableItem>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        listPurchasableItems: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            marker: z.ZodOptional<z.ZodString>;
+            sort: z.ZodOptional<z.ZodEnum<{
+                ascending: "ascending";
+                descending: "descending";
+            }>>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
+            success: false;
+            errorCode: "not_supported";
+            errorMessage: string;
+        } | import("./crud").CrudListItemsResult<PurchasableItem>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        recordPurchasableItem: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            item: z.ZodObject<{
+                address: z.ZodString;
+                name: z.ZodString;
+                description: z.ZodString;
+                imageUrls: z.ZodArray<z.ZodString>;
+                currency: z.ZodString;
+                cost: z.ZodInt;
+                taxCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                roleName: z.ZodString;
+                roleGrantTimeMs: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                redirectUrl: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
+                markers: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudRecordItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        erasePurchasableItem: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./crud").CrudEraseItemResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        purchaseItem: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            item: z.ZodObject<{
+                address: z.ZodString;
+                expectedCost: z.ZodInt;
+                currency: z.ZodString;
+            }, z.core.$strip>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+            returnUrl: z.ZodURL;
+            successUrl: z.ZodURL;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./SubscriptionController").CreatePurchaseItemLinkResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        purchaseContract: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            contract: z.ZodObject<{
+                address: z.ZodString;
+                expectedCost: z.ZodInt;
+                currency: z.ZodPrefault<z.ZodString>;
+            }, z.core.$strip>;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+            returnUrl: z.ZodURL;
+            successUrl: z.ZodURL;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("@casual-simulation/aux-common").GenericResult<{
+            url?: string;
+            sessionId: string;
+        }, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getContractPricing: Procedure<z.ZodObject<{
+            recordName: z.ZodString;
+            address: z.ZodString;
+            instances: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("@casual-simulation/aux-common").GenericResult<import("./SubscriptionController").ContractPricing, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        fulfillCheckoutSession: Procedure<z.ZodObject<{
+            sessionId: z.ZodString;
+            activation: z.ZodEnum<{
+                now: "now";
+                later: "later";
+            }>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./SubscriptionController").FulfillCheckoutSessionResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        claimActivationKey: Procedure<z.ZodObject<{
+            activationKey: z.ZodString;
+            target: z.ZodEnum<{
+                guest: "guest";
+                self: "self";
+            }>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | import("./SubscriptionController").ClaimActivationKeyResult, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        getConfigurationValue: Procedure<z.ZodObject<{
+            key: z.ZodEnum<{
+                subscriptions: "subscriptions";
+                privo: "privo";
+                moderation: "moderation";
+                web: "web";
+                playerWebManifest: "playerWebManifest";
+                ab1Bootstrap: "ab1Bootstrap";
+            }>;
+        }, z.core.$strip>, import("./AuthController").ValidateSessionKeyFailure | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | import("@casual-simulation/aux-common").GenericResult<import("./ConfigurationStore").ConfigurationOutput<"subscriptions" | "privo" | "moderation" | "web" | "playerWebManifest" | "ab1Bootstrap">, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        setConfigurationValue: Procedure<z.ZodDiscriminatedUnion<[z.core.$ZodTypeDiscriminable, ...z.core.$ZodTypeDiscriminable[]], "key">, import("./AuthController").ValidateSessionKeyFailure | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | import("@casual-simulation/aux-common").GenericResult<void, SimpleError>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
     };
-    constructor({ allowedAccountOrigins, allowedApiOrigins, authController, livekitController, recordsController, eventsController, dataController, manualDataController, filesController, subscriptionController, websocketController, websocketRateLimitController, rateLimitController, policyController, aiController, moderationController, loomController, webhooksController, notificationsController, packagesController, packageVersionController, searchRecordsController, databaseRecordsController, }: RecordsServerOptions);
+    constructor({ allowedAccountOrigins, allowedApiOrigins, authController, livekitController, recordsController, eventsController, dataController, manualDataController, filesController, subscriptionController, websocketController, websocketRateLimitController, rateLimitController, policyController, aiController, moderationController, loomController, webhooksController, notificationsController, packagesController, packageVersionController, searchRecordsController, databaseRecordsController, contractRecordsController, purchasableItemsController, viewTemplateRenderer, }: RecordsServerOptions);
     private _createProcedures;
     private _setupRoutes;
     /**
@@ -1733,7 +2544,7 @@ export declare class RecordsServer {
      * @param name The name of the procedure.
      * @param procedure The procedure that should be added.
      */
-    addProcedure<TInput, TOutput extends ProcedureOutput, TQuery>(name: string, procedure: Procedure<TInput, TOutput, TQuery>): void;
+    addProcedure<TInput extends z.ZodType | void, TOutput extends ProcedureOutput, TQuery extends z.ZodType | void>(name: string, procedure: Procedure<TInput, TOutput, TQuery>): void;
     /**
      * Adds the given procedures to the server.
      * @param procedures The procedures that should be added.
@@ -1743,16 +2554,22 @@ export declare class RecordsServer {
      * Adds the given procedural route to the server.
      * @param route The route that should be added.
      */
-    private _addProcedureRoute;
+    private _addProcedureApiRoute;
+    /**
+     * Adds the given procedural route to the server.
+     * @param route The route that should be added.
+     */
+    private _addProcedureViewRoute;
     /**
      * Adds the given route to the server.
      */
-    addRoute<T>(route: Route<T>): void;
+    addRoute<TSchema extends z.ZodType | void, TQuery extends z.ZodType | void>(route: Route<TSchema, TQuery>): void;
+    private _getRouteKey;
     /**
      * Forcefully adds the given route to the server, overwriting any routes that already exist.
      * @param route The route that should be added.
      */
-    overrideRoute<T>(route: Route<T>): void;
+    overrideRoute<TSchema extends z.ZodType | void, TQuery extends z.ZodType | void>(route: Route<TSchema, TQuery>): void;
     /**
      * Handles the given request and returns the specified response.
      * @param request The request that should be handled.
@@ -1789,6 +2606,12 @@ export declare class RecordsServer {
     private _putUserInfo;
     private _validateSessionKey;
 }
+/**
+ * Returns the given result and body as a GenericHttpResponse.
+ * @param result The result.
+ * @param body The body. If undefined, the result will be stringified and used as the body.
+ * @returns
+ */
 export declare function returnResult<T extends {
     success: false;
     errorCode: KnownErrorCodes;
@@ -1796,7 +2619,7 @@ export declare function returnResult<T extends {
     reason?: DenialReason;
 } | {
     success: true;
-}>(result: T): GenericHttpResponse;
+}>(result: T, body?: string, headers?: GenericHttpHeaders): GenericHttpResponse;
 export declare function returnProcedureOutputStream(result: ProcedureOutputStream): GenericHttpResponse;
 export declare function returnProcedureOutput(result: ProcedureOutput): GenericHttpResponse;
 /**