Variable commandSdkSurfaceConst

commandSdkSurface: Readonly<
    {
        agent: AgentApi;
        assets: {
            delete: {
                (ref: string): Promise<AssetsDeleteResult>;
                (args: AssetsDeleteArgs): Promise<AssetsDeleteResult>;
            };
            publish: {
                (
                    content: AssetContent,
                    options: AssetsPublishOptions,
                ): Promise<AssetsPublishResult>;
                (args: AssetsPublishArgs): Promise<AssetsPublishResult>;
            };
        };
        blobs: {
            put: {
                (
                    content: BlobContent,
                    options?: BlobsPutOptions,
                ): Promise<BlobsPutResult>;
                (args: BlobsPutArgs): Promise<BlobsPutResult>;
            };
        };
        chromeAuthor: {
            activateTheme(themeId: string): Promise<void>;
            commit(
                paths: string[],
                message?: string,
            ): Promise<{ committed: string[]; sha: string }>;
            list(): Promise<ChromeAuthorViewFile[]>;
            read(path: string): Promise<string>;
            status(): Promise<string[]>;
            typecheck(): Promise<{ ok: boolean; output: string }>;
            write(path: string, content: string, build?: boolean): Promise<void>;
        };
        cloud: {
            chatSession: () => Promise<CloudChatSessionResult>;
            claimChatHandle: (handle: string) => Promise<CloudChatHandleClaimResult>;
            summary: () => Promise<CloudAccountSummary>;
            support: {
                collectEvidence: () => Promise<CloudSupportEvidenceCollectResult>;
                createIssue: (
                    args: CloudSupportIssueCreateArgs,
                ) => Promise<CloudSupportIssueCreateResult>;
                getIssue: (ref: string) => Promise<CloudSupportIssueResult>;
                listIssues: (
                    args?: CloudSupportIssueListArgs,
                ) => Promise<CloudSupportIssueListResult>;
                markAffected: (
                    ref: string,
                    affected: boolean,
                ) => Promise<CloudSupportAffectedResult>;
                setIssueStatus: (
                    ref: string,
                    status:
                        | "fixed"
                        | "open"
                        | "in-progress"
                        | "closed"
                        | "needs-info"
                        | "confirmed",
                ) => Promise<CloudSupportIssueStatusResult>;
            };
        };
        connectors: {
            call: <T = unknown>(
                providerId: string,
                resource: string,
                op: string,
                input?: ProjectCommandJsonValue,
            ) => Promise<T>;
            execute: (
                input: ConnectorExecuteInput,
            ) => Promise<ConnectorExecuteResult>;
            google: {
                calendar: {
                    createEvent: (
                        input: GoogleCalendarCreateEventInput,
                    ) => Promise<GoogleCalendarEventResult>;
                    deleteEvent: (
                        input: GoogleCalendarDeleteEventInput,
                    ) => Promise<GoogleCalendarDeleteEventResult>;
                    ensureAccess: (
                        input: ConnectorEnsureAccessInput<GoogleCalendarConnectorOperation>,
                    ) => Promise<
                        ConnectorEnsureAccessResult<GoogleCalendarConnectorOperation>,
                    >;
                    freebusy: (
                        input: GoogleCalendarFreebusyInput,
                    ) => Promise<GoogleCalendarFreebusyResult>;
                    listAccounts: () => Promise<GoogleCalendarListAccountsResult>;
                    listCalendars: (
                        input?: GoogleCalendarListCalendarsInput,
                    ) => Promise<GoogleCalendarListCalendarsResult>;
                    listEvents: (
                        input: GoogleCalendarListEventsInput,
                    ) => Promise<GoogleCalendarListEventsResult>;
                    updateEvent: (
                        input: GoogleCalendarUpdateEventInput,
                    ) => Promise<GoogleCalendarEventResult>;
                };
                mail: {
                    createDraft: (
                        input: GoogleMailCreateDraftInput,
                    ) => Promise<GoogleMailDraftResult>;
                    deleteDraft: (
                        input: GoogleMailDeleteDraftInput,
                    ) => Promise<GoogleMailDeleteDraftResult>;
                    ensureAccess: (
                        input: ConnectorEnsureAccessInput<GoogleMailConnectorOperation>,
                    ) => Promise<ConnectorEnsureAccessResult<GoogleMailConnectorOperation>>;
                    getMessage: (
                        input: GoogleMailGetMessageInput,
                    ) => Promise<GoogleMailMessageResult>;
                    getThread: (
                        input: GoogleMailGetThreadInput,
                    ) => Promise<GoogleMailThreadResult>;
                    listAccounts: () => Promise<GoogleMailListAccountsResult>;
                    listLabels: (
                        input?: GoogleMailListLabelsInput,
                    ) => Promise<GoogleMailListLabelsResult>;
                    listMessages: (
                        input?: GoogleMailListMessagesInput,
                    ) => Promise<GoogleMailListMessagesResult>;
                    modifyMessage: (
                        input: GoogleMailModifyMessageInput,
                    ) => Promise<GoogleMailMessageSummaryResult>;
                    send: (
                        input: GoogleMailSendInput,
                    ) => Promise<GoogleMailMessageSummaryResult>;
                    updateDraft: (
                        input: GoogleMailUpdateDraftInput,
                    ) => Promise<GoogleMailDraftResult>;
                };
            };
        };
        dialog: DialogApi;
        entities: {
            content: {
                append: (
                    input: {
                        bytes: Uint8Array<ArrayBuffer>;
                        entityId: string;
                        idempotencyKey?: string;
                        mediaType: string;
                        metadata?: Record<string, CloudSyncJsonValue>;
                        slotId: string;
                        type: string;
                    },
                ) => Promise<
                    {
                        byteLength: number;
                        contentId: string;
                        createdAt: string;
                        entityId: string;
                        mediaType: string;
                        metadata?: Record<string, CloudSyncJsonValue>;
                        redactedAt?: string;
                        sha256: string;
                        slotId: string;
                        type: string;
                    },
                >;
                read: (
                    input: {
                        contentId: string;
                        entityId: string;
                        slotId: string;
                        type: string;
                    },
                ) => Promise<
                    {
                        bytes: Uint8Array<ArrayBuffer>;
                        content: {
                            byteLength: number;
                            contentId: string;
                            createdAt: string;
                            entityId: string;
                            mediaType: string;
                            metadata?: Record<string, CloudSyncJsonValue>;
                            redactedAt?: string;
                            sha256: string;
                            slotId: string;
                            type: string;
                        };
                    },
                >;
                redact: (
                    input: {
                        contentId: string;
                        entityId: string;
                        idempotencyKey?: string;
                        slotId: string;
                        type: string;
                    },
                ) => Promise<
                    {
                        byteLength: number;
                        contentId: string;
                        createdAt: string;
                        entityId: string;
                        mediaType: string;
                        metadata?: Record<string, CloudSyncJsonValue>;
                        redactedAt?: string;
                        sha256: string;
                        slotId: string;
                        type: string;
                    },
                >;
            };
            create: <T = unknown>(
                type: string,
                data: T,
                options?: EntityCreateOptions,
            ) => Promise<EntityRecord<T>>;
            delete: <T = unknown>(
                type: string,
                id: string,
                options?: EntityDeleteOptions,
            ) => Promise<EntityRecord<T>>;
            get: <T = unknown>(type: string, id: string) => Promise<EntityRecord<T>>;
            grant: (input: EntityGrantInput) => Promise<EntityGrant>;
            listTypes: () => Promise<EntityTypeDefinition[]>;
            query: <T = unknown>(
                type: string,
                query?: EntityQuery,
            ) => Promise<EntityQueryResult<T>>;
            requestAccess: (
                type: string,
                operations: EntityAccessOperation[],
            ) => Promise<EntityAccessRequestResult>;
            revoke: (grantId: string) => Promise<EntityGrant>;
            subscribe: (
                input: EntityWatchInput,
                onChange: EntitySubscriptionChange,
            ) => EntitySubscription;
            subscribeQuery: <T = unknown>(
                type: string,
                query: EntityQuery,
                onChange: EntityQuerySubscriptionChange<T>,
                options?: { recoveryCursor?: string },
            ) => EntityQuerySubscription<T>;
            update: <T = unknown>(
                type: string,
                id: string,
                patch: EntityPatch<NoInfer<T>>,
                options?: EntityUpdateOptions,
            ) => Promise<EntityRecord<T>>;
            watch: (input?: EntityWatchInput) => Promise<EntityWatchResult>;
        };
        files: FilesApi;
        fs: {
            delete: (path: string) => Promise<void>;
            external: {
                list: (
                    slotId: string,
                    path?: string,
                ) => Promise<ExternalFolderEntry[]>;
                readBinary: (
                    slotId: string,
                    path: string,
                ) => Promise<ExternalReadBinaryResult>;
                readText: (slotId: string, path: string) => Promise<string>;
                writeText: (
                    slotId: string,
                    path: string,
                    content: string,
                    expectedSha256: string | null,
                ) => Promise<ExternalWriteTextResult>;
            };
            list: (path?: string | undefined) => Promise<string[]>;
            read: (path: string) => Promise<string>;
            readBinary: (path: string) => Promise<Uint8Array<ArrayBufferLike>>;
            write: (path: string, content: string) => Promise<void>;
            writeBinary: (path: string, content: Uint8Array) => Promise<void>;
        };
        host: HostApi;
        picker: {
            open: (
                args?: PowerboxOpenArgs,
            ) => Promise<PowerboxPickResult | PowerboxPickResult[] | null>;
            save: (args: PowerboxSaveArgs) => Promise<PowerboxSaveResult | null>;
        };
        promptHistory: {
            listSessions: (
                args?: PromptSessionListArgs,
            ) => Promise<PromptSessionListResult>;
            readSession: (
                store: PromptHistoryStore,
                key: string,
            ) => Promise<PromptSessionDetail>;
        };
        secrets: SecretsApi;
        shared: {
            list: (path?: string | undefined) => Promise<string[]>;
            put: (
                content: string | Uint8Array<ArrayBufferLike>,
                options?: { name?: string },
            ) => Promise<SharedPutResult>;
            read: (path: string) => Promise<string>;
            write: (path: string, content: string) => Promise<SharedWriteResult>;
            writeBinary: (
                path: string,
                content: Uint8Array,
            ) => Promise<SharedWriteResult>;
        };
        ui: UiApi;
    },
> = ...