@atproto/api 0.0.8 → 0.1.0

package/README.md

@@ -3,12 +3,50 @@
 ## Usage
 
 ```typescript
-import API from '@atproto/api'
+import AtpAgent from '@atproto/api'
 
-const client = API.service('http://example.com')
+const agent = new AtpAgent({service: 'https://example.com'})
 
+// provide a custom fetch implementation (shouldnt be needed in node or the browser)
+import {AtpAgentFetchHeaders, AtpAgentFetchHandlerResponse} from '@atproto/api'
+AtpAgent.configure({
+  async fetch(
+    httpUri: string,
+    httpMethod: string,
+    httpHeaders: AtpAgentFetchHeaders,
+    httpReqBody: any,
+  ): Promise<AtpAgentFetchHandlerResponse> {
+    // insert definition here...
+    return {status: 200, /*...*/}
+  }
+})
+```
+
+### Session management
+
+```typescript
+import AtpAgent, {AtpSessionEvent, AtpSessionData} from '@atproto/api'
+const agent = new AtpAgent({
+  service: 'https://example.com',
+  persistSession: (evt: AtpSessionEvent, sess?: AtpSessionData) {
+    // store the session-data for reuse 
+  }
+})
+
+await agent.login({identifier: 'alice@mail.com', password: 'hunter2'})
+await agent.resumeSession(savedSessionData)
+await agent.createAccount({
+  email: 'alice@mail.com',
+  password: 'hunter2',
+  handle: 'alice.example.com'
+})
+```
+
+### API calls
+
+```typescript
 // xrpc methods
-const res1 = await client.com.atproto.repo.createRecord(
+const res1 = await agent.api.com.atproto.repo.createRecord(
   {
     did: alice.did,
     collection: 'app.bsky.feed.post',
@@ -19,14 +57,14 @@ const res1 = await client.com.atproto.repo.createRecord(
     }
   }
 )
-const res2 = await client.com.atproto.repo.listRecords({did: alice.did, type: 'app.bsky.feed.post'})
+const res2 = await agent.api.com.atproto.repo.listRecords({did: alice.did, type: 'app.bsky.feed.post'})
 
 // repo record methods
-const res3 = await client.app.bsky.feed.post.create({did: alice.did}, {
+const res3 = await agent.api.app.bsky.feed.post.create({did: alice.did}, {
   text: 'Hello, world!',
   createdAt: (new Date()).toISOString()
 })
-const res4 = await client.app.bsky.feed.post.list({did: alice.did})
+const res4 = await agent.api.app.bsky.feed.post.list({did: alice.did})
 ```
 
 ## License

package/dist/agent.d.ts

@@ -0,0 +1,22 @@
+import { AtpServiceClient, ComAtprotoAccountCreate, ComAtprotoSessionCreate, ComAtprotoSessionGet } from './client';
+import { AtpSessionData, AtpAgentCreateAccountOpts, AtpAgentLoginOpts, AptAgentFetchHandler, AtpAgentGlobalOpts, AtpPersistSessionHandler, AtpAgentOpts } from './types';
+export declare class AtpAgent {
+    service: URL;
+    api: AtpServiceClient;
+    session?: AtpSessionData;
+    private _baseClient;
+    private _persistSession?;
+    private _refreshSessionPromise;
+    static fetch: AptAgentFetchHandler | undefined;
+    static configure(opts: AtpAgentGlobalOpts): void;
+    constructor(opts: AtpAgentOpts);
+    get hasSession(): boolean;
+    setPersistSessionHandler(handler?: AtpPersistSessionHandler): void;
+    createAccount(opts: AtpAgentCreateAccountOpts): Promise<ComAtprotoAccountCreate.Response>;
+    login(opts: AtpAgentLoginOpts): Promise<ComAtprotoSessionCreate.Response>;
+    resumeSession(session: AtpSessionData): Promise<ComAtprotoSessionGet.Response>;
+    private _addAuthHeader;
+    private _fetch;
+    private _refreshSession;
+    private _refreshSessionInner;
+}

package/dist/client/index.d.ts

@@ -70,6 +70,7 @@ export * as ComAtprotoAccountGet from './types/com/atproto/account/get';
 export * as ComAtprotoAccountRequestDelete from './types/com/atproto/account/requestDelete';
 export * as ComAtprotoAccountRequestPasswordReset from './types/com/atproto/account/requestPasswordReset';
 export * as ComAtprotoAccountResetPassword from './types/com/atproto/account/resetPassword';
+export * as ComAtprotoAdminBlob from './types/com/atproto/admin/blob';
 export * as ComAtprotoAdminGetModerationAction from './types/com/atproto/admin/getModerationAction';
 export * as ComAtprotoAdminGetModerationActions from './types/com/atproto/admin/getModerationActions';
 export * as ComAtprotoAdminGetModerationReport from './types/com/atproto/admin/getModerationReport';
@@ -160,28 +161,26 @@ export declare const APP_BSKY_GRAPH: {
 export declare const APP_BSKY_SYSTEM: {
     ActorUser: string;
 };
-export declare class Client {
+export declare class AtpBaseClient {
     xrpc: XrpcClient;
     constructor();
-    service(serviceUri: string | URL): ServiceClient;
+    service(serviceUri: string | URL): AtpServiceClient;
 }
-declare const defaultInst: Client;
-export default defaultInst;
-export declare class ServiceClient {
-    _baseClient: Client;
+export declare class AtpServiceClient {
+    _baseClient: AtpBaseClient;
     xrpc: XrpcServiceClient;
     com: ComNS;
     app: AppNS;
-    constructor(baseClient: Client, xrpcService: XrpcServiceClient);
+    constructor(baseClient: AtpBaseClient, xrpcService: XrpcServiceClient);
     setHeader(key: string, value: string): void;
 }
 export declare class ComNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     atproto: AtprotoNS;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
 }
 export declare class AtprotoNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     account: AccountNS;
     admin: AdminNS;
     blob: BlobNS;
@@ -191,11 +190,11 @@ export declare class AtprotoNS {
     server: ServerNS;
     session: SessionNS;
     sync: SyncNS;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
 }
 export declare class AccountNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     create(data?: ComAtprotoAccountCreate.InputSchema, opts?: ComAtprotoAccountCreate.CallOptions): Promise<ComAtprotoAccountCreate.Response>;
     createInviteCode(data?: ComAtprotoAccountCreateInviteCode.InputSchema, opts?: ComAtprotoAccountCreateInviteCode.CallOptions): Promise<ComAtprotoAccountCreateInviteCode.Response>;
     delete(data?: ComAtprotoAccountDelete.InputSchema, opts?: ComAtprotoAccountDelete.CallOptions): Promise<ComAtprotoAccountDelete.Response>;
@@ -205,8 +204,8 @@ export declare class AccountNS {
     resetPassword(data?: ComAtprotoAccountResetPassword.InputSchema, opts?: ComAtprotoAccountResetPassword.CallOptions): Promise<ComAtprotoAccountResetPassword.Response>;
 }
 export declare class AdminNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     getModerationAction(params?: ComAtprotoAdminGetModerationAction.QueryParams, opts?: ComAtprotoAdminGetModerationAction.CallOptions): Promise<ComAtprotoAdminGetModerationAction.Response>;
     getModerationActions(params?: ComAtprotoAdminGetModerationActions.QueryParams, opts?: ComAtprotoAdminGetModerationActions.CallOptions): Promise<ComAtprotoAdminGetModerationActions.Response>;
     getModerationReport(params?: ComAtprotoAdminGetModerationReport.QueryParams, opts?: ComAtprotoAdminGetModerationReport.CallOptions): Promise<ComAtprotoAdminGetModerationReport.Response>;
@@ -219,18 +218,18 @@ export declare class AdminNS {
     takeModerationAction(data?: ComAtprotoAdminTakeModerationAction.InputSchema, opts?: ComAtprotoAdminTakeModerationAction.CallOptions): Promise<ComAtprotoAdminTakeModerationAction.Response>;
 }
 export declare class BlobNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     upload(data?: ComAtprotoBlobUpload.InputSchema, opts?: ComAtprotoBlobUpload.CallOptions): Promise<ComAtprotoBlobUpload.Response>;
 }
 export declare class HandleNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     resolve(params?: ComAtprotoHandleResolve.QueryParams, opts?: ComAtprotoHandleResolve.CallOptions): Promise<ComAtprotoHandleResolve.Response>;
 }
 export declare class RepoNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     batchWrite(data?: ComAtprotoRepoBatchWrite.InputSchema, opts?: ComAtprotoRepoBatchWrite.CallOptions): Promise<ComAtprotoRepoBatchWrite.Response>;
     createRecord(data?: ComAtprotoRepoCreateRecord.InputSchema, opts?: ComAtprotoRepoCreateRecord.CallOptions): Promise<ComAtprotoRepoCreateRecord.Response>;
     deleteRecord(data?: ComAtprotoRepoDeleteRecord.InputSchema, opts?: ComAtprotoRepoDeleteRecord.CallOptions): Promise<ComAtprotoRepoDeleteRecord.Response>;
@@ -240,26 +239,26 @@ export declare class RepoNS {
     putRecord(data?: ComAtprotoRepoPutRecord.InputSchema, opts?: ComAtprotoRepoPutRecord.CallOptions): Promise<ComAtprotoRepoPutRecord.Response>;
 }
 export declare class ReportNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     create(data?: ComAtprotoReportCreate.InputSchema, opts?: ComAtprotoReportCreate.CallOptions): Promise<ComAtprotoReportCreate.Response>;
 }
 export declare class ServerNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     getAccountsConfig(params?: ComAtprotoServerGetAccountsConfig.QueryParams, opts?: ComAtprotoServerGetAccountsConfig.CallOptions): Promise<ComAtprotoServerGetAccountsConfig.Response>;
 }
 export declare class SessionNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     create(data?: ComAtprotoSessionCreate.InputSchema, opts?: ComAtprotoSessionCreate.CallOptions): Promise<ComAtprotoSessionCreate.Response>;
     delete(data?: ComAtprotoSessionDelete.InputSchema, opts?: ComAtprotoSessionDelete.CallOptions): Promise<ComAtprotoSessionDelete.Response>;
     get(params?: ComAtprotoSessionGet.QueryParams, opts?: ComAtprotoSessionGet.CallOptions): Promise<ComAtprotoSessionGet.Response>;
     refresh(data?: ComAtprotoSessionRefresh.InputSchema, opts?: ComAtprotoSessionRefresh.CallOptions): Promise<ComAtprotoSessionRefresh.Response>;
 }
 export declare class SyncNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     getCheckout(params?: ComAtprotoSyncGetCheckout.QueryParams, opts?: ComAtprotoSyncGetCheckout.CallOptions): Promise<ComAtprotoSyncGetCheckout.Response>;
     getCommitPath(params?: ComAtprotoSyncGetCommitPath.QueryParams, opts?: ComAtprotoSyncGetCommitPath.CallOptions): Promise<ComAtprotoSyncGetCommitPath.Response>;
     getHead(params?: ComAtprotoSyncGetHead.QueryParams, opts?: ComAtprotoSyncGetHead.CallOptions): Promise<ComAtprotoSyncGetHead.Response>;
@@ -267,24 +266,24 @@ export declare class SyncNS {
     getRepo(params?: ComAtprotoSyncGetRepo.QueryParams, opts?: ComAtprotoSyncGetRepo.CallOptions): Promise<ComAtprotoSyncGetRepo.Response>;
 }
 export declare class AppNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     bsky: BskyNS;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
 }
 export declare class BskyNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     actor: ActorNS;
     embed: EmbedNS;
     feed: FeedNS;
     graph: GraphNS;
     notification: NotificationNS;
     system: SystemNS;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
 }
 export declare class ActorNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     profile: ProfileRecord;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
     getProfile(params?: AppBskyActorGetProfile.QueryParams, opts?: AppBskyActorGetProfile.CallOptions): Promise<AppBskyActorGetProfile.Response>;
     getSuggestions(params?: AppBskyActorGetSuggestions.QueryParams, opts?: AppBskyActorGetSuggestions.CallOptions): Promise<AppBskyActorGetSuggestions.Response>;
     search(params?: AppBskyActorSearch.QueryParams, opts?: AppBskyActorSearch.CallOptions): Promise<AppBskyActorSearch.Response>;
@@ -292,8 +291,8 @@ export declare class ActorNS {
     updateProfile(data?: AppBskyActorUpdateProfile.InputSchema, opts?: AppBskyActorUpdateProfile.CallOptions): Promise<AppBskyActorUpdateProfile.Response>;
 }
 export declare class ProfileRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -313,15 +312,15 @@ export declare class ProfileRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class EmbedNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
 }
 export declare class FeedNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     post: PostRecord;
     repost: RepostRecord;
     vote: VoteRecord;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
     getAuthorFeed(params?: AppBskyFeedGetAuthorFeed.QueryParams, opts?: AppBskyFeedGetAuthorFeed.CallOptions): Promise<AppBskyFeedGetAuthorFeed.Response>;
     getPostThread(params?: AppBskyFeedGetPostThread.QueryParams, opts?: AppBskyFeedGetPostThread.CallOptions): Promise<AppBskyFeedGetPostThread.Response>;
     getRepostedBy(params?: AppBskyFeedGetRepostedBy.QueryParams, opts?: AppBskyFeedGetRepostedBy.CallOptions): Promise<AppBskyFeedGetRepostedBy.Response>;
@@ -330,8 +329,8 @@ export declare class FeedNS {
     setVote(data?: AppBskyFeedSetVote.InputSchema, opts?: AppBskyFeedSetVote.CallOptions): Promise<AppBskyFeedSetVote.Response>;
 }
 export declare class PostRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -351,8 +350,8 @@ export declare class PostRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class RepostRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -372,8 +371,8 @@ export declare class RepostRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class VoteRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -393,11 +392,11 @@ export declare class VoteRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class GraphNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     assertion: AssertionRecord;
     confirmation: ConfirmationRecord;
     follow: FollowRecord;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
     getFollowers(params?: AppBskyGraphGetFollowers.QueryParams, opts?: AppBskyGraphGetFollowers.CallOptions): Promise<AppBskyGraphGetFollowers.Response>;
     getFollows(params?: AppBskyGraphGetFollows.QueryParams, opts?: AppBskyGraphGetFollows.CallOptions): Promise<AppBskyGraphGetFollows.Response>;
     getMutes(params?: AppBskyGraphGetMutes.QueryParams, opts?: AppBskyGraphGetMutes.CallOptions): Promise<AppBskyGraphGetMutes.Response>;
@@ -405,8 +404,8 @@ export declare class GraphNS {
     unmute(data?: AppBskyGraphUnmute.InputSchema, opts?: AppBskyGraphUnmute.CallOptions): Promise<AppBskyGraphUnmute.Response>;
 }
 export declare class AssertionRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -426,8 +425,8 @@ export declare class AssertionRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class ConfirmationRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -447,8 +446,8 @@ export declare class ConfirmationRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class FollowRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {
@@ -468,20 +467,20 @@ export declare class FollowRecord {
     delete(params: Omit<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>, headers?: Record<string, string>): Promise<void>;
 }
 export declare class NotificationNS {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     getCount(params?: AppBskyNotificationGetCount.QueryParams, opts?: AppBskyNotificationGetCount.CallOptions): Promise<AppBskyNotificationGetCount.Response>;
     list(params?: AppBskyNotificationList.QueryParams, opts?: AppBskyNotificationList.CallOptions): Promise<AppBskyNotificationList.Response>;
     updateSeen(data?: AppBskyNotificationUpdateSeen.InputSchema, opts?: AppBskyNotificationUpdateSeen.CallOptions): Promise<AppBskyNotificationUpdateSeen.Response>;
 }
 export declare class SystemNS {
-    _service: ServiceClient;
+    _service: AtpServiceClient;
     declaration: DeclarationRecord;
-    constructor(service: ServiceClient);
+    constructor(service: AtpServiceClient);
 }
 export declare class DeclarationRecord {
-    _service: ServiceClient;
-    constructor(service: ServiceClient);
+    _service: AtpServiceClient;
+    constructor(service: AtpServiceClient);
     list(params: Omit<ComAtprotoRepoListRecords.QueryParams, 'collection'>): Promise<{
         cursor?: string;
         records: {

package/dist/client/lexicons.d.ts

@@ -193,6 +193,75 @@ export declare const schemaDict: {
             };
         };
     };
+    ComAtprotoAdminBlob: {
+        lexicon: number;
+        id: string;
+        defs: {
+            view: {
+                type: string;
+                required: string[];
+                properties: {
+                    cid: {
+                        type: string;
+                    };
+                    mimeType: {
+                        type: string;
+                    };
+                    size: {
+                        type: string;
+                    };
+                    createdAt: {
+                        type: string;
+                    };
+                    details: {
+                        type: string;
+                        refs: string[];
+                    };
+                    moderation: {
+                        type: string;
+                        ref: string;
+                    };
+                };
+            };
+            imageDetails: {
+                type: string;
+                required: string[];
+                properties: {
+                    width: {
+                        type: string;
+                    };
+                    height: {
+                        type: string;
+                    };
+                };
+            };
+            videoDetails: {
+                type: string;
+                required: string[];
+                properties: {
+                    width: {
+                        type: string;
+                    };
+                    height: {
+                        type: string;
+                    };
+                    length: {
+                        type: string;
+                    };
+                };
+            };
+            moderation: {
+                type: string;
+                required: never[];
+                properties: {
+                    currentAction: {
+                        type: string;
+                        ref: string;
+                    };
+                };
+            };
+        };
+    };
     ComAtprotoAdminGetModerationAction: {
         lexicon: number;
         id: string;
@@ -408,12 +477,18 @@ export declare const schemaDict: {
                     };
                     action: {
                         type: string;
-                        knownValues: string[];
+                        ref: string;
                     };
                     subject: {
                         type: string;
                         refs: string[];
                     };
+                    subjectBlobCids: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
                     reason: {
                         type: string;
                     };
@@ -444,12 +519,19 @@ export declare const schemaDict: {
                     };
                     action: {
                         type: string;
-                        knownValues: string[];
+                        ref: string;
                     };
                     subject: {
                         type: string;
                         refs: string[];
                     };
+                    subjectBlobs: {
+                        type: string;
+                        items: {
+                            type: string;
+                            ref: string;
+                        };
+                    };
                     reason: {
                         type: string;
                     };
@@ -472,6 +554,19 @@ export declare const schemaDict: {
                     };
                 };
             };
+            viewCurrent: {
+                type: string;
+                required: string[];
+                properties: {
+                    id: {
+                        type: string;
+                    };
+                    action: {
+                        type: string;
+                        ref: string;
+                    };
+                };
+            };
             reversal: {
                 type: string;
                 required: string[];
@@ -487,6 +582,10 @@ export declare const schemaDict: {
                     };
                 };
             };
+            actionType: {
+                type: string;
+                knownValues: string[];
+            };
             takedown: {
                 type: string;
                 description: string;
@@ -589,6 +688,12 @@ export declare const schemaDict: {
                     value: {
                         type: string;
                     };
+                    blobCids: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
                     indexedAt: {
                         type: string;
                     };
@@ -615,6 +720,13 @@ export declare const schemaDict: {
                     value: {
                         type: string;
                     };
+                    blobs: {
+                        type: string;
+                        items: {
+                            type: string;
+                            ref: string;
+                        };
+                    };
                     indexedAt: {
                         type: string;
                     };
@@ -632,8 +744,9 @@ export declare const schemaDict: {
                 type: string;
                 required: never[];
                 properties: {
-                    takedownId: {
+                    currentAction: {
                         type: string;
+                        ref: string;
                     };
                 };
             };
@@ -641,6 +754,10 @@ export declare const schemaDict: {
                 type: string;
                 required: string[];
                 properties: {
+                    currentAction: {
+                        type: string;
+                        ref: string;
+                    };
                     actions: {
                         type: string;
                         items: {
@@ -655,9 +772,6 @@ export declare const schemaDict: {
                             ref: string;
                         };
                     };
-                    takedownId: {
-                        type: string;
-                    };
                 };
             };
         };
@@ -737,8 +851,9 @@ export declare const schemaDict: {
                 type: string;
                 required: never[];
                 properties: {
-                    takedownId: {
+                    currentAction: {
                         type: string;
+                        ref: string;
                     };
                 };
             };
@@ -746,6 +861,10 @@ export declare const schemaDict: {
                 type: string;
                 required: string[];
                 properties: {
+                    currentAction: {
+                        type: string;
+                        ref: string;
+                    };
                     actions: {
                         type: string;
                         items: {
@@ -760,9 +879,6 @@ export declare const schemaDict: {
                             ref: string;
                         };
                     };
-                    takedownId: {
-                        type: string;
-                    };
                 };
             };
         };
@@ -907,6 +1023,12 @@ export declare const schemaDict: {
                                 type: string;
                                 refs: string[];
                             };
+                            subjectBlobCids: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                };
+                            };
                             reason: {
                                 type: string;
                             };
@@ -923,6 +1045,9 @@ export declare const schemaDict: {
                         ref: string;
                     };
                 };
+                errors: {
+                    name: string;
+                }[];
             };
         };
     };
@@ -2034,18 +2159,6 @@ export declare const schemaDict: {
                     indexedAt: {
                         type: string;
                     };
-                    myState: {
-                        type: string;
-                        ref: string;
-                    };
-                };
-            };
-            myState: {
-                type: string;
-                properties: {
-                    follow: {
-                        type: string;
-                    };
                 };
             };
         };
@@ -3630,6 +3743,7 @@ export declare const ids: {
     ComAtprotoAccountRequestDelete: string;
     ComAtprotoAccountRequestPasswordReset: string;
     ComAtprotoAccountResetPassword: string;
+    ComAtprotoAdminBlob: string;
     ComAtprotoAdminGetModerationAction: string;
     ComAtprotoAdminGetModerationActions: string;
     ComAtprotoAdminGetModerationReport: string;