@casual-simulation/aux-records 3.2.18 → 3.2.19

package/RecordsServer.d.ts

@@ -1,4 +1,3 @@
-import { KnownErrorCodes } from './Utils';
 import { AuthController } from './AuthController';
 import { LivekitController } from './LivekitController';
 import { RecordsController } from './RecordsController';
@@ -8,10 +7,11 @@ import { FileRecordsController } from './FileRecordsController';
 import { SubscriptionController } from './SubscriptionController';
 import { z } from 'zod';
 import { RateLimitController } from './RateLimitController';
+import { Procedure, ProcedureOutput } from '@casual-simulation/aux-common';
 import { PolicyController } from './PolicyController';
 import { AIController } from './AIController';
 import { WebsocketController } from './websockets/WebsocketController';
-import { GenericHttpRequest, GenericHttpResponse, GenericWebsocketRequest } from '@casual-simulation/aux-common';
+import { GenericHttpRequest, GenericHttpResponse, GenericWebsocketRequest, KnownErrorCodes } from '@casual-simulation/aux-common';
 import { ModerationController } from './ModerationController';
 export declare const NOT_LOGGED_IN_RESULT: {
     success: false;
@@ -19,7 +19,7 @@ export declare const NOT_LOGGED_IN_RESULT: {
     errorMessage: "The user is not logged in. A session key must be provided for this operation.";
 };
 export declare const UNACCEPTABLE_SESSION_KEY: {
-    success: boolean;
+    success: false;
     errorCode: "unacceptable_session_key";
     errorMessage: string;
 };
@@ -29,37 +29,37 @@ export declare const UNACCEPTABLE_USER_ID: {
     errorMessage: string;
 };
 export declare const INVALID_ORIGIN_RESULT: {
-    success: boolean;
+    success: false;
     errorCode: "invalid_origin";
     errorMessage: string;
 };
 export declare const OPERATION_NOT_FOUND_RESULT: {
-    success: boolean;
+    success: false;
     errorCode: "operation_not_found";
     errorMessage: string;
 };
 export declare const UNACCEPTABLE_REQUEST_RESULT_MUST_BE_JSON: {
-    success: boolean;
+    success: false;
     errorCode: "unacceptable_request";
     errorMessage: string;
 };
 export declare const SUBSCRIPTIONS_NOT_SUPPORTED_RESULT: {
-    success: boolean;
+    success: false;
     errorCode: "not_supported";
     errorMessage: string;
 };
 export declare const AI_NOT_SUPPORTED_RESULT: {
-    success: boolean;
+    success: false;
     errorCode: "not_supported";
     errorMessage: string;
 };
 export declare const INSTS_NOT_SUPPORTED_RESULT: {
-    success: boolean;
+    success: false;
     errorCode: "not_supported";
     errorMessage: string;
 };
 export declare const MODERATION_NOT_SUPPORTED_RESULT: {
-    success: boolean;
+    success: false;
     errorCode: "not_supported";
     errorMessage: string;
 };
@@ -91,16 +91,22 @@ export declare const DISPLAY_NAME_VALIDATION: z.ZodString;
 export declare const NAME_VALIDATION: z.ZodString;
 export declare const RECORD_NAME_VALIDATION: z.ZodString;
 export declare const INSTANCE_VALIDATION: z.ZodString;
-export declare const INSTANCES_ARRAY_VALIDATION: z.ZodArray<z.ZodString, "many">;
+export declare const INSTANCES_ARRAY_VALIDATION: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], unknown>;
 export declare const INSTANCES_QUERY_VALIDATION: z.ZodEffects<z.ZodString, string[], string>;
 /**
  * Defines a basic interface for an HTTP route.
  */
-export interface Route {
+export interface Route<T> {
     /**
      * The path that the route must match.
      */
     path: string;
+    /**
+     * 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>;
     /**
      * The method for the route.
      */
@@ -108,8 +114,17 @@ export interface Route {
     /**
      * 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.
      */
-    handler: (request: GenericHttpRequest) => Promise<GenericHttpResponse>;
+    handler: (request: GenericHttpRequest, data?: T) => Promise<GenericHttpResponse>;
+    /**
+     * The set of origins that are allowed for the route.
+     * If true, then all origins are allowed.
+     * If 'account', then only the configured account origins are allowed.
+     * If 'api', then only the configured API origins are allowed.
+     * If omitted, then it is up to the handler to determine if the origin is allowed.
+     */
+    allowedOrigins?: Set<string> | true | 'account' | 'api';
 }
 /**
  * Defines a class that represents a generic HTTP server suitable for Records HTTP Requests.
@@ -141,6 +156,7 @@ export declare class RecordsServer {
      * The map of paths to routes that they match.
      */
     private _routes;
+    private _procedures;
     /**
      * The set of origins that are allowed for account management requests.
      */
@@ -149,11 +165,724 @@ export declare class RecordsServer {
      * The set of origins that are allowed for API requests.
      */
     get allowedApiOrigins(): Set<string>;
+    /**
+     * The set of procedures that the server has.
+     */
+    get procedures(): {
+        isEmailValid: Procedure<{
+            email?: string;
+        }, import("./AuthController").IsValidEmailAddressResult>;
+        isDisplayNameValid: Procedure<{
+            displayName?: string;
+            name?: string;
+        }, import("./AuthController").IsValidDisplayNameResult>;
+        listSessions: Procedure<{
+            expireTimeMs?: number;
+        }, 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.";
+        }>;
+        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.";
+        }>;
+        revokeAllSessions: Procedure<{
+            userId?: string;
+        }, 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.";
+        }>;
+        revokeSession: Procedure<{
+            userId?: string;
+            sessionId?: string;
+            sessionKey?: string;
+        }, 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.";
+        }>;
+        completeLogin: Procedure<{
+            userId?: string;
+            requestId?: string;
+            code?: string;
+        }, import("./AuthController").CompleteLoginResult>;
+        requestLogin: Procedure<{
+            address?: string;
+            addressType?: "email" | "phone";
+        }, import("./AuthController").LoginRequestResult>;
+        requestPrivoLogin: Procedure<{}, import("./AuthController").OpenIDLoginRequestResult>;
+        processOAuthCode: Procedure<{
+            code?: string;
+            state?: string;
+        }, import("./AuthController").ProcessOpenIDAuthorizationCodeResult>;
+        completeOAuthLogin: Procedure<{
+            requestId?: string;
+        }, import("./AuthController").CompleteOpenIDLoginResult>;
+        requestPrivoSignUp: Procedure<{
+            email?: string;
+            parentEmail?: string;
+            name?: string;
+            dateOfBirth?: Date;
+            displayName?: string;
+        }, import("./AuthController").PrivoSignUpRequestResult>;
+        getWebAuthnRegistrationOptions: Procedure<void, import("./AuthController").RequestWebAuthnRegistrationResult | import("./AuthController").ValidateSessionKeyFailure>;
+        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>;
+        getWebAuthnLoginOptions: Procedure<void, import("./AuthController").RequestWebAuthnLoginResult>;
+        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>;
+        listUserAuthenticators: Procedure<void, import("./AuthController").ListUserAuthenticatorsResult | import("./AuthController").ValidateSessionKeyFailure>;
+        deleteUserAuthenticator: Procedure<{
+            authenticatorId?: string;
+        }, import("./AuthController").DeleteUserAuthenticatorResult | import("./AuthController").ValidateSessionKeyFailure>;
+        createMeetToken: Procedure<{
+            roomName?: string;
+            userName?: string;
+        }, import("./LivekitEvents").IssueMeetTokenResult>;
+        createRecord: Procedure<{
+            recordName?: string;
+            ownerId?: string;
+            studioId?: string;
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").CreateRecordResult>;
+        addEventCount: Procedure<{
+            recordKey?: string;
+            eventName?: string;
+            count?: number;
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./EventRecordsController").AddCountResult>;
+        getEventCount: Procedure<{
+            recordName?: string;
+            eventName?: string;
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./EventRecordsController").GetCountResult>;
+        listEvents: Procedure<{
+            recordName?: string;
+            eventName?: string;
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./EventRecordsController").ListEventsResult>;
+        updateEvent: Procedure<{
+            recordKey?: string;
+            eventName?: string;
+            count?: number;
+            markers?: [string, ...string[]];
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./EventRecordsController").UpdateEventRecordResult>;
+        deleteManualData: Procedure<{
+            recordKey?: string;
+            address?: string;
+            instances?: string[];
+        }, 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.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "address is required and must be a string.";
+        }>;
+        getManualData: Procedure<{
+            recordName?: string;
+            address?: string;
+            instances?: string[];
+        }, 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.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "address is required and must be a string.";
+        }>;
+        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 | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "recordKey is required and must be a string.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "address is required and must be a string.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "data is required.";
+        }>;
+        getFile: Procedure<{
+            recordName?: string;
+            fileName?: string;
+            fileUrl?: string;
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsStore").GetFileNameFromUrlFailure | import("./FileRecordsController").ReadFileSuccess | import("./FileRecordsController").ReadFileFailure | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: string;
+        }>;
+        listFiles: Procedure<{
+            recordName?: string;
+            fileName?: string;
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsController").ListFilesSuccess | import("./FileRecordsController").ListFilesFailure | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "recordName must be a string.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "fileName must be a string.";
+        }>;
+        eraseFile: Procedure<{
+            recordKey?: string;
+            fileUrl?: string;
+            instances?: string[];
+        }, 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.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "fileUrl is required and must be a string.";
+        }>;
+        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 | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "recordKey is required and must be a string.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "fileSha256Hex is required and must be a string.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "fileByteLength is required and must be a number.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "fileMimeType is required and must be a string.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "fileDescription must be a string.";
+        }>;
+        updateFile: Procedure<{
+            recordKey?: string;
+            fileUrl?: string;
+            markers?: [string, ...string[]];
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./FileRecordsStore").GetFileNameFromUrlFailure | import("./FileRecordsController").UpdateFileRecordSuccess | import("./FileRecordsController").UpdateFileRecordFailure>;
+        eraseData: Procedure<{
+            recordKey?: string;
+            address?: string;
+            instances?: string[];
+        }, 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.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "address is required and must be a string.";
+        }>;
+        getData: Procedure<{
+            recordName?: string;
+            address?: string;
+            instances?: string[];
+        }, 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.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "address is required and must be a string.";
+        }>;
+        listData: Procedure<{
+            recordName?: string;
+            address?: string;
+            marker?: string;
+            sort?: "ascending" | "descending";
+            instances?: string[];
+        }, 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.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "address must be null or a string.";
+        }>;
+        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 | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "recordKey is required and must be a string.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "address is required and must be a string.";
+        } | {
+            readonly success: false;
+            readonly errorCode: "unacceptable_request";
+            readonly errorMessage: "data is required.";
+        }>;
+        listRecords: Procedure<{
+            studioId?: string;
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").ListRecordsResult>;
+        createRecordKey: Procedure<{
+            recordName?: string;
+            policy?: string;
+        }, 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.";
+        }>;
+        grantPermission: Procedure<{
+            recordName?: string;
+            permission?: {
+                marker?: string;
+                subjectType?: "user" | "role" | "inst";
+                subjectId?: string;
+                resourceId?: string;
+                expireTimeMs?: number;
+                resourceKind?: "data";
+                action?: "create" | "read" | "update" | "delete" | "list";
+            } | {
+                marker?: string;
+                subjectType?: "user" | "role" | "inst";
+                subjectId?: string;
+                resourceId?: string;
+                expireTimeMs?: number;
+                resourceKind?: "file";
+                action?: "create" | "read" | "update" | "delete" | "list";
+                options?: {
+                    maxFileSizeInBytes?: number;
+                    allowedMimeTypes?: true | string[];
+                };
+            } | {
+                marker?: string;
+                subjectType?: "user" | "role" | "inst";
+                subjectId?: string;
+                expireTimeMs?: number;
+                resourceKind?: "event";
+                resourceId?: string;
+                action?: "update" | "increment" | "count" | "list";
+            } | {
+                marker?: string;
+                subjectType?: "user" | "role" | "inst";
+                subjectId?: string;
+                resourceId?: string;
+                expireTimeMs?: number;
+                resourceKind?: "marker";
+                action?: "read" | "assign" | "unassign" | "grantPermission" | "revokePermission";
+            } | {
+                marker?: string;
+                subjectType?: "user" | "role" | "inst";
+                subjectId?: string;
+                resourceId?: string;
+                expireTimeMs?: number;
+                resourceKind?: "role";
+                action?: "read" | "update" | "list" | "grant" | "revoke";
+                options?: {
+                    maxDurationMs?: number;
+                };
+            } | {
+                marker?: string;
+                subjectType?: "user" | "role" | "inst";
+                subjectId?: string;
+                resourceId?: string;
+                expireTimeMs?: number;
+                resourceKind?: "inst";
+                action?: "create" | "read" | "update" | "delete" | "list" | "sendAction" | "updateData";
+            };
+            instances?: string[];
+        }, 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.";
+        }>;
+        revokePermission: Procedure<{
+            permissionId?: string;
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").RevokePermissionResult>;
+        listPermissions: Procedure<{
+            recordName?: string;
+            marker?: string;
+            resourceKind?: "data" | "role" | "event" | "inst" | "file" | "marker";
+            resourceId?: string;
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").ListPermissionsFailure | import("./PolicyController").ListPermissionsForMarkerSuccess | import("./PolicyController").ListPermissionsForResourceSuccess>;
+        listUserRoles: Procedure<{
+            recordName?: string;
+            userId?: string;
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").ListAssignedUserRolesResult>;
+        listInstRoles: Procedure<{
+            recordName?: string;
+            inst?: string;
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").ListAssignedInstRolesResult>;
+        listRoleAssignments: Procedure<{
+            recordName?: string;
+            startingRole?: string;
+            role?: string;
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").ListRoleAssignmentsResult>;
+        grantRole: Procedure<{
+            recordName?: string;
+            userId?: string;
+            inst?: string;
+            role?: string;
+            expireTimeMs?: number;
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").GrantRoleResult>;
+        revokeRole: Procedure<{
+            recordName?: string;
+            userId?: string;
+            inst?: string;
+            role?: string;
+            instances?: string[];
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./PolicyController").RevokeRoleResult>;
+        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("./AIController").AIChatResponse | 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;
+        }>;
+        createAiSkybox: Procedure<{
+            prompt?: string;
+            negativePrompt?: string;
+            blockadeLabs?: {
+                skyboxStyleId?: number;
+                remixImagineId?: number;
+                seed?: number;
+            };
+            instances?: string[];
+        }, import("./AIController").AIGenerateSkyboxResponse | 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;
+        }>;
+        getAiSkybox: Procedure<{
+            skyboxId?: string;
+            instances?: string[];
+        }, import("./AIController").AIGetSkyboxResponse | 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;
+        }>;
+        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("./AIController").AIGenerateImageResponse | 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;
+        }>;
+        getStudio: Procedure<{
+            studioId?: string;
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").GetStudioResult>;
+        createStudio: Procedure<{
+            displayName?: string;
+            ownerStudioComId?: string;
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").CreateStudioSuccess | import("./RecordsController").CreateStudioInComIdFailure>;
+        updateStudio: Procedure<{
+            id?: string;
+            displayName?: string;
+            logoUrl?: 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")[];
+                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";
+                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";
+            };
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").UpdateStudioResult>;
+        requestStudioComId: Procedure<{
+            studioId?: string;
+            comId?: string;
+        }, 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.";
+        }>;
+        listStudios: Procedure<{
+            comId?: string;
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").ListStudiosResult>;
+        listStudioMembers: Procedure<{
+            studioId?: string;
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").ListStudioMembersResult>;
+        addStudioMember: Procedure<{
+            studioId?: string;
+            addedUserId?: string;
+            addedEmail?: string;
+            addedPhoneNumber?: string;
+            role?: "admin" | "member";
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").AddStudioMemberResult>;
+        removeStudioMember: Procedure<{
+            studioId?: string;
+            removedUserId?: string;
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./RecordsController").RemoveStudioMemberResult>;
+        getPlayerConfig: Procedure<{
+            comId?: string;
+        }, import("./RecordsController").GetPlayerConfigResult>;
+        getSubscriptions: Procedure<{
+            studioId?: string;
+            userId?: string;
+        }, import("./SubscriptionController").GetSubscriptionStatusSuccess | import("./SubscriptionController").GetSubscriptionStatusFailure | {
+            success: false;
+            errorCode: "not_logged_in";
+            errorMessage: "The user is not logged in. A session key must be provided for this operation.";
+        } | {
+            readonly success: true;
+            readonly publishableKey: string;
+            readonly subscriptions: {
+                active: boolean;
+                statusCode: "active" | "trialing" | "canceled" | "ended" | "past_due" | "unpaid" | "incomplete" | "incomplete_expired" | "paused";
+                productName: string;
+                startDate: number;
+                endedDate: number;
+                cancelDate: number;
+                canceledDate: number;
+                currentPeriodStart: number;
+                currentPeriodEnd: number;
+                renewalInterval: "year" | "month" | "day" | "week";
+                intervalLength: number;
+                intervalCost: number;
+                currency: string;
+                featureList: string[];
+            }[];
+            readonly purchasableSubscriptions: {
+                id: string;
+                name: string;
+                description: string;
+                featureList: string[];
+                prices: {
+                    id: string;
+                    interval: "year" | "month" | "day" | "week";
+                    intervalLength: number;
+                    currency: string;
+                    cost: number;
+                }[];
+                defaultSubscription: boolean;
+            }[];
+        }>;
+        getManageSubscriptionLink: Procedure<{
+            userId?: string;
+            studioId?: string;
+            subscriptionId?: string;
+            expectedPrice?: {
+                currency?: string;
+                cost?: number;
+                interval?: "year" | "month" | "day" | "week";
+                intervalLength?: number;
+            };
+        }, 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.";
+        }>;
+        listInsts: Procedure<{
+            recordName?: string;
+            inst?: string;
+        }, import("./AuthController").ValidateSessionKeyFailure | 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;
+        } | NoSessionKeyResult>;
+        deleteInst: Procedure<{
+            recordKey?: string;
+            recordName?: string;
+            inst?: string;
+        }, import("./AuthController").ValidateSessionKeyFailure | 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;
+        } | NoSessionKeyResult>;
+        reportInst: Procedure<{
+            recordName?: string;
+            inst?: string;
+            automaticReport?: boolean;
+            reportReason?: "poor-performance" | "spam" | "harassment" | "copyright-infringement" | "obscene" | "illegal" | "other";
+            reportReasonText?: string;
+            reportedUrl?: string;
+            reportedPermalink?: string;
+        }, import("./AuthController").ValidateSessionKeyFailure | import("./ModerationController").ReportInstResult | {
+            success: false;
+            errorCode: "not_supported";
+            errorMessage: string;
+        }>;
+        getInstData: Procedure<{
+            recordName?: string;
+            inst?: string;
+            branch?: string;
+        }, import("./AuthController").ValidateSessionKeyFailure | {
+            success: true;
+            data: import("@casual-simulation/aux-common").StoredAux;
+        } | {
+            success: false;
+            errorCode: "server_error" | "invalid_record_key" | "unacceptable_request" | "record_not_found" | "not_authorized" | "action_not_supported" | "not_logged_in" | "subscription_limit_reached" | "inst_not_found";
+            errorMessage: string;
+            reason?: import("@casual-simulation/aux-common").DenialReason;
+        }>;
+    };
     constructor(allowedAccountOrigins: Set<string>, allowedApiOrigins: Set<string>, authController: AuthController, livekitController: LivekitController, recordsController: RecordsController, eventsController: EventRecordsController, dataController: DataRecordsController, manualDataController: DataRecordsController, filesController: FileRecordsController, subscriptionController: SubscriptionController | null, rateLimitController: RateLimitController, policyController: PolicyController, aiController: AIController | null, websocketController: WebsocketController | null, moderationController: ModerationController | null, websocketRateLimitController?: RateLimitController | null);
+    private _createProcedures;
+    private _setupRoutes;
+    /**
+     * Adds the given procedure to the server.
+     * @param name The name of the procedure.
+     * @param procedure The procedure that should be added.
+     */
+    addProcedure<TInput, TOutput extends ProcedureOutput>(name: string, procedure: Procedure<TInput, TOutput>): void;
+    /**
+     * Adds the given procedural route to the server.
+     * @param route The route that should be added.
+     */
+    private _addProcedureRoute;
     /**
      * Adds the given route to the server.
      */
-    addRoute(route: Route): void;
+    addRoute<T>(route: Route<T>): void;
+    /**
+     * 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;
     /**
      * Handles the given request and returns the specified response.
      * @param request The request that should be handled.
@@ -169,34 +898,7 @@ export declare class RecordsServer {
     private _processWebsocketDownload;
     private _processWebsocketUploadRequest;
     private _stripeWebhook;
-    private _isEmailValid;
-    private _isDisplayNameValid;
     private _handleOptions;
-    private _listRecords;
-    private _createRecord;
-    private _createRecordKey;
-    private _grantPermission;
-    private _revokePermission;
-    private _listPermissions;
-    private _roleUserList;
-    private _roleInstList;
-    private _roleAssignmentsList;
-    private _roleGrant;
-    private _roleRevoke;
-    private _aiChat;
-    private _aiSkybox;
-    private _aiGetSkybox;
-    private _aiGenerateImage;
-    private _getStudio;
-    private _postStudio;
-    private _updateStudio;
-    private _requestComId;
-    private _listStudios;
-    private _listStudioMembers;
-    private _addStudioMember;
-    private _removeStudioMember;
-    private _getPlayerConfig;
-    private _listData;
     private _handleRecordFileOptions;
     private _recordFile;
     private _updateFile;
@@ -204,49 +906,18 @@ export declare class RecordsServer {
     private _listFiles;
     private _eraseFile;
     private _baseRecordData;
-    private _recordData;
-    private _manualRecordData;
     private _baseGetRecordData;
-    private _getData;
-    private _getManualRecordData;
     private _baseEraseRecordData;
-    private _eraseData;
-    private _eraseManualRecordData;
-    private _getRecordsEventsCount;
-    private _postRecordsEventsCount;
-    private _listEvents;
-    private _postRecordsEvents;
-    private _postMeetToken;
-    private _postLogin;
-    private _privoLogin;
-    private _oauthProvideCode;
-    private _oauthCompleteLogin;
-    private _registerPrivo;
-    private _webAuthnRegisterOptions;
-    private _webAuthnRegister;
-    private _webAuthnLoginOptions;
-    private _webAuthnLogin;
-    private _listWebAuthnAuthenticators;
-    private _deleteWebAuthnAuthenticator;
-    private _postCompleteLogin;
-    private _postRevokeSession;
-    private _postRevokeAllSessions;
     private _postReplaceSession;
-    private _getSessions;
     private _getSubscriptionInfo;
-    private _getSubscriptionInfoV2;
     private _manageSubscription;
-    private _manageSubscriptionV2;
-    private _listInsts;
-    private _deleteInst;
-    private _reportInst;
-    private _getInstData;
     /**
      * Endpoint to retrieve info about a user.
      * @param request The request.
      */
     private _getUserInfo;
     private _putUserInfo;
+    private _validateHttpSessionKey;
     private _validateSessionKey;
 }
 export declare function returnResult<T extends {