Class ObservableSanityStegaClient

Deprecated

-- Use import {ObservableSanityClient} from '@sanity/client' instead

Hierarchy (View Summary)

ObservableSanityClient
- ObservableSanityStegaClient

Index

Constructors

constructor

new ObservableSanityStegaClient(
httpRequest: HttpRequest,
config?: ClientConfig,
): ObservableSanityStegaClient
Parameters
- httpRequest: HttpRequest
- config: ClientConfig = defaultConfig
Returns ObservableSanityStegaClient
Inherited from ObservableSanityClient.constructor
- Defined in src/SanityClient.ts:154

Properties - Releases

releases

releases: {
    archive(
        params: { releaseId: string },
        options?: BaseActionOptions,
    ): Observable<SingleActionResult>;
    create(
        options: BaseActionOptions,
    ): Observable<
        SingleActionResult & {
            metadata: {
                cardinality?: ReleaseCardinality;
                description?: string;
                intendedPublishAt?: string;
                releaseType: ReleaseType;
                title?: string;
            };
            releaseId: string;
        },
    >;
    create(
        release: {
            metadata?: Partial<
                {
                    cardinality?: ReleaseCardinality;
                    description?: string;
                    intendedPublishAt?: string;
                    releaseType: ReleaseType;
                    title?: string;
                },
            >;
            releaseId?: string;
        },
        options?: BaseActionOptions,
    ): Observable<
        SingleActionResult & {
            metadata: {
                cardinality?: ReleaseCardinality;
                description?: string;
                intendedPublishAt?: string;
                releaseType: ReleaseType;
                title?: string;
            };
            releaseId: string;
        },
    >;
    delete(
        params: { releaseId: string },
        options?: BaseActionOptions,
    ): Observable<SingleActionResult>;
    edit(
        params: { patch: PatchOperations; releaseId: string },
        options?: BaseActionOptions,
    ): Observable<SingleActionResult>;
    fetchDocuments(
        params: { releaseId: string },
        options?: BaseMutationOptions,
    ): Observable<RawQueryResponse<SanityDocument[]>>;
    get(
        params: { releaseId: string },
        options?: { signal?: AbortSignal; tag?: string },
    ): Observable<ReleaseDocument | undefined>;
    publish(
        params: { releaseId: string },
        options?: BaseActionOptions,
    ): Observable<SingleActionResult>;
    schedule(
        params: { publishAt: string; releaseId: string },
        options?: BaseActionOptions,
    ): Observable<SingleActionResult>;
    unarchive(
        params: { releaseId: string },
        options?: BaseActionOptions,
    ): Observable<SingleActionResult>;
    unschedule(
        params: { releaseId: string },
        options?: BaseActionOptions,
    ): Observable<SingleActionResult>;
}

Create and manage content releases and their scheduled publishing

Type declaration

archive: function
- archive(
  params: { releaseId: string },
  options?: BaseActionOptions,
  ): Observable<SingleActionResult>
  An archive action removes an active release. The documents that comprise the release are deleted and therefore no longer queryable.
  
  While the documents remain in retention the last version can still be accessed using document history endpoint.
  Parameters
  - params: { releaseId: string }
    Release action parameters:
    
    releaseId - The id of the release to archive.
  - Optionaloptions: BaseActionOptions
    Additional action options.
  Returns Observable<SingleActionResult>
  An observable that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:233
create: function
- create(
      options: BaseActionOptions,
  ): Observable<
      SingleActionResult & {
          metadata: {
              cardinality?: ReleaseCardinality;
              description?: string;
              intendedPublishAt?: string;
              releaseType: ReleaseType;
              title?: string;
          };
          releaseId: string;
      },
  >
  Creates a new release under the given id, with metadata.
  Parameters
  - options: BaseActionOptions
    Additional action options.
  Returns Observable<
      SingleActionResult & {
          metadata: {
              cardinality?: ReleaseCardinality;
              description?: string;
              intendedPublishAt?: string;
              releaseType: ReleaseType;
              title?: string;
          };
          releaseId: string;
      },
  >
  An observable that resolves to the transactionId and the release id and metadata.
  Remarks
  
  If no releaseId is provided, a release id will be generated.
  
  If no metadata is provided, then an undecided releaseType will be used.
  Example: Creating a release with a custom id and metadata
  const releaseId = 'my-release' const metadata: ReleaseDocument['metadata'] = { releaseType: 'asap', } client.observable.releases.create({releaseId, metadata}).pipe( tap(({transactionId, releaseId, metadata}) => console.log(transactionId, releaseId, metadata)), // { // transactionId: 'transaction-id', // releaseId: 'my-release', // metadata: {releaseType: 'asap'}, // } ).subscribe()
  Example: Creating a release with generated id and metadata
  client.observable.releases.create().pipe( tap(({metadata}) => console.log(metadata)), // { // metadata: {releaseType: 'undecided'}, // } ).subscribe()
  Example: Creating a release using a custom transaction id
  client.observable.releases.create({transactionId: 'my-transaction-id'}).pipe( tap(({transactionId, metadata}) => console.log(transactionId, metadata)), // { // transactionId: 'my-transaction-id', // metadata: {releaseType: 'undecided'}, // } ).subscribe()
  - Defined in src/releases/ReleasesClient.ts:137
- create(
      release: {
          metadata?: Partial<
              {
                  cardinality?: ReleaseCardinality;
                  description?: string;
                  intendedPublishAt?: string;
                  releaseType: ReleaseType;
                  title?: string;
              },
          >;
          releaseId?: string;
      },
      options?: BaseActionOptions,
  ): Observable<
      SingleActionResult & {
          metadata: {
              cardinality?: ReleaseCardinality;
              description?: string;
              intendedPublishAt?: string;
              releaseType: ReleaseType;
              title?: string;
          };
          releaseId: string;
      },
  >
  Creates a new release under the given id, with metadata.
  Parameters
  - release: {
        metadata?: Partial<
            {
                cardinality?: ReleaseCardinality;
                description?: string;
                intendedPublishAt?: string;
                releaseType: ReleaseType;
                title?: string;
            },
        >;
        releaseId?: string;
    }
  - Optionaloptions: BaseActionOptions
    Additional action options.
  Returns Observable<
      SingleActionResult & {
          metadata: {
              cardinality?: ReleaseCardinality;
              description?: string;
              intendedPublishAt?: string;
              releaseType: ReleaseType;
              title?: string;
          };
          releaseId: string;
      },
  >
  An observable that resolves to the transactionId and the release id and metadata.
  Remarks
  
  If no releaseId is provided, a release id will be generated.
  
  If no metadata is provided, then an undecided releaseType will be used.
  Example: Creating a release with a custom id and metadata
  const releaseId = 'my-release' const metadata: ReleaseDocument['metadata'] = { releaseType: 'asap', } client.observable.releases.create({releaseId, metadata}).pipe( tap(({transactionId, releaseId, metadata}) => console.log(transactionId, releaseId, metadata)), // { // transactionId: 'transaction-id', // releaseId: 'my-release', // metadata: {releaseType: 'asap'}, // } ).subscribe()
  Example: Creating a release with generated id and metadata
  client.observable.releases.create().pipe( tap(({metadata}) => console.log(metadata)), // { // metadata: {releaseType: 'undecided'}, // } ).subscribe()
  Example: Creating a release using a custom transaction id
  client.observable.releases.create({transactionId: 'my-transaction-id'}).pipe( tap(({transactionId, metadata}) => console.log(transactionId, metadata)), // { // transactionId: 'my-transaction-id', // metadata: {releaseType: 'undecided'}, // } ).subscribe()
  - Defined in src/releases/ReleasesClient.ts:140
delete: function
- delete(
  params: { releaseId: string },
  options?: BaseActionOptions,
  ): Observable<SingleActionResult>
  A delete action removes a published or archived release. The backing system document will be removed from the dataset.
  Parameters
  - params: { releaseId: string }
    Release action parameters:
    
    releaseId - The id of the release to delete.
  - Optionaloptions: BaseActionOptions
    Additional action options.
  Returns Observable<SingleActionResult>
  An observable that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:339
edit: function
- edit(
  params: { patch: PatchOperations; releaseId: string },
  options?: BaseActionOptions,
  ): Observable<SingleActionResult>
  Edits an existing release, updating the metadata.
  Parameters
  - params: { patch: PatchOperations; releaseId: string }
    Release action parameters:
    
    releaseId - The id of the release to edit.
    
    patch - The patch operation to apply on the release metadata PatchMutationOperation.
  - Optionaloptions: BaseActionOptions
    Additional action options.
  Returns Observable<SingleActionResult>
  An observable that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:175
fetchDocuments: function
- fetchDocuments(
  params: { releaseId: string },
  options?: BaseMutationOptions,
  ): Observable<RawQueryResponse<SanityDocument[]>>
  Fetch the documents in a release by release id.
  Parameters
  - params: { releaseId: string }
    Release action parameters:
    
    releaseId - The id of the release to fetch documents for.
  - Optionaloptions: BaseMutationOptions
    Additional mutation options BaseMutationOptions.
  Returns Observable<RawQueryResponse<SanityDocument[]>>
  An observable that resolves to the documents in the release.
  - Defined in src/releases/ReleasesClient.ts:363
get: function
- get(
  params: { releaseId: string },
  options?: { signal?: AbortSignal; tag?: string },
  ): Observable<ReleaseDocument | undefined>
  Retrieve a release by id.
  Parameters
  - params: { releaseId: string }
    Release action parameters:
    
    releaseId - The id of the release to retrieve.
  - Optionaloptions: { signal?: AbortSignal; tag?: string }
    Additional query options including abort signal and query tag.
  Returns Observable<ReleaseDocument | undefined>
  An observable that resolves to the release document ReleaseDocument.
  Example: Retrieving a release by id
  client.observable.releases.get({releaseId: 'my-release'}).pipe( tap((release) => console.log(release)), // { // _id: '_.releases.my-release', // name: 'my-release' // _type: 'system.release', // metadata: {releaseType: 'asap'}, // _createdAt: '2021-01-01T00:00:00.000Z', // ... // } ).subscribe()
  - Defined in src/releases/ReleasesClient.ts:70
publish: function
- publish(
  params: { releaseId: string },
  options?: BaseActionOptions,
  ): Observable<SingleActionResult>
  Publishes all documents in a release at once. For larger releases the effect of the publish will be visible immediately when querying but the removal of the versions.<releasesId>.* documents and creation of the corresponding published documents with the new content may take some time.
  
  During this period both the source and target documents are locked and cannot be modified through any other means.
  Parameters
  - params: { releaseId: string }
    Release action parameters:
    
    releaseId - The id of the release to publish.
  - Optionaloptions: BaseActionOptions
    Additional action options.
  Returns Observable<SingleActionResult>
  An observable that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:206
schedule: function
- schedule(
  params: { publishAt: string; releaseId: string },
  options?: BaseActionOptions,
  ): Observable<SingleActionResult>
  A schedule action queues a release for publishing at the given future time. The release is locked such that no documents in the release can be modified and no documents that it references can be deleted as this would make the publish fail. At the given time, the same logic as for the publish action is triggered.
  Parameters
  - params: { publishAt: string; releaseId: string }
    Release action parameters:
    
    releaseId - The id of the release to schedule.
    
    publishAt - The serialised date and time to publish the release. If the publishAt is in the past, the release will be published immediately.
  - Optionaloptions: BaseActionOptions
    Additional action options.
  Returns Observable<SingleActionResult>
  An observable that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:286
unarchive: function
- unarchive(
  params: { releaseId: string },
  options?: BaseActionOptions,
  ): Observable<SingleActionResult>
  An unarchive action restores an archived release and all documents with the content they had just prior to archiving.
  Parameters
  - params: { releaseId: string }
    Release action parameters:
    
    releaseId - The id of the release to unarchive.
  - Optionaloptions: BaseActionOptions
    Additional action options.
  Returns Observable<SingleActionResult>
  An observable that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:258
unschedule: function
- unschedule(
  params: { releaseId: string },
  options?: BaseActionOptions,
  ): Observable<SingleActionResult>
  An unschedule action stops a release from being published. The documents in the release are considered unlocked and can be edited again. This may fail if another release is scheduled to be published after this one and has a reference to a document created by this one.
  Parameters
  - params: { releaseId: string }
    Release action parameters:
    
    releaseId - The id of the release to unschedule.
  - Optionaloptions: BaseActionOptions
    Additional action options.
  Returns Observable<SingleActionResult>
  An observable that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:314

Properties - Assets

assets

assets: {
    upload(
        assetType: "file",
        body: UploadBody,
        options?: UploadClientConfig,
    ): Observable<UploadEvent<{ document: SanityAssetDocument }>>;
    upload(
        assetType: "image",
        body: UploadBody,
        options?: UploadClientConfig,
    ): Observable<UploadEvent<{ document: SanityImageAssetDocument }>>;
    upload(
        assetType: "file" | "image",
        body: UploadBody,
        options?: UploadClientConfig,
    ): Observable<
        UploadEvent<
            { document: SanityAssetDocument
            | SanityImageAssetDocument },
        >,
    >;
}

Upload, fetch and delete assets (images and files) in the configured dataset

Type declaration

upload: function
- upload(
      assetType: "file",
      body: UploadBody,
      options?: UploadClientConfig,
  ): Observable<UploadEvent<{ document: SanityAssetDocument }>>
  Uploads a file asset to the configured dataset
  Parameters
  - assetType: "file"
    Asset type (file)
  - body: UploadBody
    Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
  - Optionaloptions: UploadClientConfig
    Options to use for the upload
  Returns Observable<UploadEvent<{ document: SanityAssetDocument }>>
  - Defined in src/assets/AssetsClient.ts:40
- upload(
      assetType: "image",
      body: UploadBody,
      options?: UploadClientConfig,
  ): Observable<UploadEvent<{ document: SanityImageAssetDocument }>>
  Uploads an image asset to the configured dataset
  Parameters
  - assetType: "image"
    Asset type (image)
  - body: UploadBody
    Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
  - Optionaloptions: UploadClientConfig
    Options to use for the upload
  Returns Observable<UploadEvent<{ document: SanityImageAssetDocument }>>
  - Defined in src/assets/AssetsClient.ts:53
- upload(
      assetType: "file" | "image",
      body: UploadBody,
      options?: UploadClientConfig,
  ): Observable<
      UploadEvent<
          { document: SanityAssetDocument
          | SanityImageAssetDocument },
      >,
  >
  Uploads a file or an image asset to the configured dataset
  Parameters
  - assetType: "file" | "image"
    Asset type (file/image)
  - body: UploadBody
    Asset content - can be a browser File instance, a Blob, a Node.js Buffer instance or a Node.js ReadableStream.
  - Optionaloptions: UploadClientConfig
    Options to use for the upload
  Returns Observable<
      UploadEvent<
          { document: SanityAssetDocument
          | SanityImageAssetDocument },
      >,
  >
  - Defined in src/assets/AssetsClient.ts:65

mediaLibrary

mediaLibrary: {
    video: {
        getPlaybackInfo(
            assetIdentifier: MediaLibraryAssetInstanceIdentifier,
            options?: MediaLibraryPlaybackInfoOptions,
        ): Observable<
            VideoPlaybackInfo<
                VideoPlaybackInfoItem,
                VideoRenditionInfo,
                VideoSubtitleInfo,
            >,
        >;
    };
}

Interact with Media Library assets

Type declaration

video: {
    getPlaybackInfo(
        assetIdentifier: MediaLibraryAssetInstanceIdentifier,
        options?: MediaLibraryPlaybackInfoOptions,
    ): Observable<
        VideoPlaybackInfo<
            VideoPlaybackInfoItem,
            VideoRenditionInfo,
            VideoSubtitleInfo,
        >,
    >;
}
Upload and manage Media Library video assets
- getPlaybackInfo: function
  - getPlaybackInfo(
        assetIdentifier: MediaLibraryAssetInstanceIdentifier,
        options?: MediaLibraryPlaybackInfoOptions,
    ): Observable<
        VideoPlaybackInfo<
            VideoPlaybackInfoItem,
            VideoRenditionInfo,
            VideoSubtitleInfo,
        >,
    >
    Get video playback information for a media library asset
    Parameters
    assetIdentifier: MediaLibraryAssetInstanceIdentifier
    Asset instance identifier (GDR, video-prefixed ID, or container ID)
    
    options: MediaLibraryPlaybackInfoOptions = {}
    Options for transformations and expiration
    Returns Observable<
        VideoPlaybackInfo<
            VideoPlaybackInfoItem,
            VideoRenditionInfo,
            VideoSubtitleInfo,
        >,
    >
    Defined in src/mediaLibrary/MediaLibraryVideoClient.ts:31

Properties - Agent Actions

agent

agent: {
    action: {
        generate<DocumentShape extends Record<string, any>>(
            request: GenerateInstruction<DocumentShape>,
        ): Observable<
            { [key: string]: any } & { _id: string } & { [key: string]: any } & {
                _type: string;
            } & DocumentShape,
        >;
        transform<DocumentShape extends Record<string, any>>(
            request: TransformDocument<T>,
        ): Observable<
            { [key: string]: any } & { _id: string } & { [key: string]: any } & {
                _type: string;
            } & DocumentShape,
        >;
        translate<DocumentShape extends Record<string, any>>(
            request: TranslateDocument<T>,
        ): Observable<
            { [key: string]: any } & { _id: string } & { [key: string]: any } & {
                _type: string;
            } & DocumentShape,
        >;
    };
}

Run Agent Actions - AI-powered operations to generate, transform, translate, prompt and patch documents

Type declaration

action: {
    generate<DocumentShape extends Record<string, any>>(
        request: GenerateInstruction<DocumentShape>,
    ): Observable<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >;
    transform<DocumentShape extends Record<string, any>>(
        request: TransformDocument<T>,
    ): Observable<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >;
    translate<DocumentShape extends Record<string, any>>(
        request: TranslateDocument<T>,
    ): Observable<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >;
}
Run individual Agent Action operations
- generate: function
  - generate<DocumentShape extends Record<string, any>>(
        request: GenerateInstruction<DocumentShape>,
    ): Observable<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >
    Run an instruction to generate content in a target document.
    Type Parameters
    DocumentShape extends Record<string, any>
    Parameters
    request: GenerateInstruction<DocumentShape>
    instruction request
    Returns Observable<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >
    Defined in src/agent/actions/AgentActionsClient.ts:27
- transform: function
  - transform<DocumentShape extends Record<string, any>>(
        request: TransformDocument<T>,
    ): Observable<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >
    Transform a target document based on a source.
    Type Parameters
    DocumentShape extends Record<string, any>
    Parameters
    request: TransformDocument<T>
    translation request
    Returns Observable<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >
    Defined in src/agent/actions/AgentActionsClient.ts:41
- translate: function
  - translate<DocumentShape extends Record<string, any>>(
        request: TranslateDocument<T>,
    ): Observable<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >
    Translate a target document based on a source.
    Type Parameters
    DocumentShape extends Record<string, any>
    Parameters
    request: TranslateDocument<T>
    translation request
    Returns Observable<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >
    Defined in src/agent/actions/AgentActionsClient.ts:55

Properties - Real-time

listen

listen: {
    <
        R extends Record<string, any> = Record<string, any>,
        const G extends string = string,
    >(
        this: SanityClient | ObservableSanityClient,
        query: G,
        params?: ClientParams<G, ListenParams> | QueryWithoutParams,
    ): Observable<MutationEvent<R>>;
    <
        R extends Record<string, any> = Record<string, any>,
        Opts extends
            ListenOptions | ResumableListenOptions =
            | ListenOptions
            | ResumableListenOptions,
        const G extends string = string,
    >(
        this: SanityClient | ObservableSanityClient,
        query: G,
        params?: QueryWithoutParams | ClientParams<G, ListenParams>,
        options?: Opts,
    ): Observable<ListenEventFromOptions<R, Opts>>;
} = _listen

Listen to document changes matching a GROQ query, delivered as server-sent events

Type declaration

- <
      R extends Record<string, any> = Record<string, any>,
      const G extends string = string,
  >(
      this: SanityClient | ObservableSanityClient,
      query: G,
      params?: ClientParams<G, ListenParams> | QueryWithoutParams,
  ): Observable<MutationEvent<R>>
- Set up a listener that will be notified when mutations occur on documents matching the provided query/filter.
  Type Parameters
  - R extends Record<string, any> = Record<string, any>
  - const G extends string = string
  Parameters
  - this: SanityClient | ObservableSanityClient
  - query: G
    GROQ-filter to listen to changes for
  - Optionalparams: ClientParams<G, ListenParams> | QueryWithoutParams
    Optional query parameters
  Returns Observable<MutationEvent<R>>
- <
      R extends Record<string, any> = Record<string, any>,
      Opts extends
          ListenOptions | ResumableListenOptions =
          | ListenOptions
          | ResumableListenOptions,
      const G extends string = string,
  >(
      this: SanityClient | ObservableSanityClient,
      query: G,
      params?: QueryWithoutParams | ClientParams<G, ListenParams>,
      options?: Opts,
  ): Observable<ListenEventFromOptions<R, Opts>>
- Set up a listener that will be notified when mutations occur on documents matching the provided query/filter.
  Type Parameters
  - R extends Record<string, any> = Record<string, any>
  - Opts extends ListenOptions | ResumableListenOptions = ListenOptions | ResumableListenOptions
  - const G extends string = string
  Parameters
  - this: SanityClient | ObservableSanityClient
  - query: G
    GROQ-filter to listen to changes for
  - Optionalparams: QueryWithoutParams | ClientParams<G, ListenParams>
    Optional query parameters
  - Optionaloptions: Opts
    Optional listener options
  Returns Observable<ListenEventFromOptions<R, Opts>>

live

live: {
    events(
        __namedParameters?: {
            includeDrafts?: boolean;
            tag?: string;
            waitFor?: "function";
        },
    ): Observable<LiveEvent>;
}

Subscribe to live content updates through the Live Content API

Type declaration

events: function
- events(
      __namedParameters?: {
          includeDrafts?: boolean;
          tag?: string;
          waitFor?: "function";
      },
  ): Observable<LiveEvent>
  Requires apiVersion to be 2021-03-25 or later.
  Parameters
  - __namedParameters: { includeDrafts?: boolean; tag?: string; waitFor?: "function" } = {}
    OptionalincludeDrafts?: boolean
    Optionaltag?: string
    Optional request tag for the listener. Use to identify the request in logs.
    
    Default Value
    undefined
    
    OptionalwaitFor?: "function"
    Delays events until after a Sanity Function has processed them and called the callback endpoint. When omitted, events are delivered immediately.
  Returns Observable<LiveEvent>
  - Defined in src/data/live.ts:40

Properties - Projects & Datasets

datasets

datasets: {
    create(
        name: string,
        options?: DatasetCreateOptions,
    ): Observable<DatasetResponse>;
    delete(name: string): Observable<{ deleted: true }>;
    edit(
        name: string,
        options?: DatasetEditOptions,
    ): Observable<DatasetResponse>;
    editEmbeddingsSettings(
        name: string,
        settings: EmbeddingsSettingsBody,
    ): Observable<void>;
    getEmbeddingsSettings(name: string): Observable<EmbeddingsSettings>;
    list(): Observable<DatasetsResponse>;
}

Create, list, edit and delete datasets in the configured project

Type declaration

create: function
- create(
  name: string,
  options?: DatasetCreateOptions,
  ): Observable<DatasetResponse>
  Create a new dataset with the given name
  Parameters
  - name: string
    Name of the dataset to create
  - Optionaloptions: DatasetCreateOptions
    Options for the dataset, including optional embeddings configuration
  Returns Observable<DatasetResponse>
  - Defined in src/datasets/DatasetsClient.ts:34
delete: function
- delete(name: string): Observable<{ deleted: true }>
  Delete a dataset with the given name
  Parameters
  - name: string
    Name of the dataset to delete
  Returns Observable<{ deleted: true }>
  - Defined in src/datasets/DatasetsClient.ts:59
edit: function
- edit(name: string, options?: DatasetEditOptions): Observable<DatasetResponse>
  Edit a dataset with the given name
  Parameters
  - name: string
    Name of the dataset to edit
  - Optionaloptions: DatasetEditOptions
    New options for the dataset
  Returns Observable<DatasetResponse>
  - Defined in src/datasets/DatasetsClient.ts:44
editEmbeddingsSettings: function
- editEmbeddingsSettings(
  name: string,
  settings: EmbeddingsSettingsBody,
  ): Observable<void>
  Edit embeddings settings for a dataset
  Parameters
  - name: string
    Name of the dataset
  - settings: EmbeddingsSettingsBody
    Embeddings settings to apply
  Returns Observable<void>
  - Defined in src/datasets/DatasetsClient.ts:101
getEmbeddingsSettings: function
- getEmbeddingsSettings(name: string): Observable<EmbeddingsSettings>
  Get embeddings settings for a dataset
  Parameters
  - name: string
    Name of the dataset
  Returns Observable<EmbeddingsSettings>
  - Defined in src/datasets/DatasetsClient.ts:86
list: function
- list(): Observable<DatasetsResponse>
  Fetch a list of datasets for the configured project
  
  Returns Observable<DatasetsResponse>
  - Defined in src/datasets/DatasetsClient.ts:66

projects

projects: {
    getById(projectId: string): Observable<SanityProject>;
    list<T extends ListOptions>(
        options?: T,
    ): Observable<Omit<SanityProject, OmittedProjectFields<T>>[]>;
}

Fetch information about the projects the authenticated user has access to

Type declaration

getById: function
- getById(projectId: string): Observable<SanityProject>
  Fetch a project by project ID
  Parameters
  - projectId: string
    ID of the project to fetch
  Returns Observable<SanityProject>
  - Defined in src/projects/ProjectsClient.ts:68
list: function
- list<T extends ListOptions>(
  options?: T,
  ): Observable<Omit<SanityProject, OmittedProjectFields<T>>[]>
  Fetch a list of projects the authenticated user has access to.
  Type Parameters
  - T extends ListOptions
  Parameters
  - Optionaloptions: T
    Options for the list request
    
    includeMembers - Whether to include members in the response (default: true)
    
    includeFeatures - Whether to include features in the response (default: true)
    
    organizationId - ID of the organization to fetch projects for
    
    onlyExplicitMembership - Whether to include only projects with explicit membership (default: false)
  Returns Observable<Omit<SanityProject, OmittedProjectFields<T>>[]>
  - Defined in src/projects/ProjectsClient.ts:39

users

users: {
    getById<T extends string>(
        id: T,
    ): Observable<T extends "me" ? CurrentSanityUser : SanityUser>;
}

Fetch information about users in the configured project

Type declaration

getById: function
- getById<T extends string>(
  id: T,
  ): Observable<T extends "me" ? CurrentSanityUser : SanityUser>
  Fetch a user by user ID
  Type Parameters
  - T extends string
  Parameters
  - id: T
    User ID of the user to fetch. If me is provided, a minimal response including the users role is returned.
  Returns Observable<T extends "me" ? CurrentSanityUser : SanityUser>
  - Defined in src/users/UsersClient.ts:24

Properties - Other

collaboration

collaboration: { comments: ObservableCollaborationCommentsClient }

`Beta`context

context: ObservableContextClient

functions

functions: ObservableFunctionsClient

Methods - Configuration

clone

clone(): ObservableSanityClient
Clone the client - returns a new instance

Returns ObservableSanityClient
Inherited from ObservableSanityClient.clone
- Defined in src/SanityClient.ts:183

config

config(): InitializedClientConfig
Returns the current client configuration

Returns InitializedClientConfig
Inherited from ObservableSanityClient.config
- Defined in src/SanityClient.ts:192
config(newConfig?: Partial<ClientConfig>): this
Reconfigure the client. Note that this mutates the current client.
Parameters
- OptionalnewConfig: Partial<ClientConfig>
Returns this
Inherited from ObservableSanityClient.config
- Defined in src/SanityClient.ts:196

withConfig

withConfig(newConfig?: Partial<ClientConfig>): ObservableSanityClient
Clone the client with a new (partial) configuration.
Parameters
- OptionalnewConfig: Partial<ClientConfig>
  New client configuration properties, shallowly merged with existing configuration
Returns ObservableSanityClient
Inherited from ObservableSanityClient.withConfig
- Defined in src/SanityClient.ts:219

Methods - Querying

documentsExists

documentsExists(
ids: string[],
options?: { signal?: AbortSignal; tag?: string },
): Observable<Set<string>>
Convenient and bandwidth efficient method of checking wether a set of document IDs exists. Returns a set of the IDs that exist.
Parameters
- ids: string[]
  Document IDs to check
- Optionaloptions: { signal?: AbortSignal; tag?: string }
  Request options
Returns Observable<Set<string>>
Inherited from ObservableSanityClient.documentsExists
- Defined in src/SanityClient.ts:393

fetch

fetch<
    R = any,
    Q extends QueryWithoutParams = QueryWithoutParams,
    const G extends string = string,
>(
    query: G,
    params?: QueryWithoutParams | Q,
): Observable<ClientReturn<G, R>>
Perform a GROQ-query against the configured dataset.
Type Parameters
- R = any
- Q extends QueryWithoutParams = QueryWithoutParams
- const G extends string = string
Parameters
- query: G
  GROQ-query to perform
- Optionalparams: QueryWithoutParams | Q
Returns Observable<ClientReturn<G, R>>
Inherited from ObservableSanityClient.fetch
- Defined in src/SanityClient.ts:240
fetch<
    R = any,
    Q extends QueryWithoutParams | QueryParams = QueryParams,
    const G extends string = string,
>(
    query: G,
    params: Q extends QueryWithoutParams
        ? QueryWithoutParams
        : ClientParams<G, Q>,
    options?: FilteredResponseQueryOptions,
): Observable<ClientReturn<G, R>>
Perform a GROQ-query against the configured dataset.
Type Parameters
- R = any
- Q extends QueryWithoutParams | QueryParams = QueryParams
- const G extends string = string
Parameters
- query: G
  GROQ-query to perform
- params: Q extends QueryWithoutParams ? QueryWithoutParams : ClientParams<G, Q>
  Optional query parameters
- Optionaloptions: FilteredResponseQueryOptions
  Optional request options
Returns Observable<ClientReturn<G, R>>
Inherited from ObservableSanityClient.fetch
- Defined in src/SanityClient.ts:252
fetch<
    R = any,
    Q extends QueryWithoutParams | QueryParams = QueryParams,
    const G extends string = string,
>(
    query: G,
    params: Q extends QueryWithoutParams
        ? QueryWithoutParams
        : ClientParams<G, Q>,
    options: UnfilteredResponseQueryOptions,
): Observable<RawQueryResponse<ClientReturn<G, R>>>
Perform a GROQ-query against the configured dataset.
Type Parameters
- R = any
- Q extends QueryWithoutParams | QueryParams = QueryParams
- const G extends string = string
Parameters
- query: G
  GROQ-query to perform
- params: Q extends QueryWithoutParams ? QueryWithoutParams : ClientParams<G, Q>
  Optional query parameters
- options: UnfilteredResponseQueryOptions
  Request options
Returns Observable<RawQueryResponse<ClientReturn<G, R>>>
Inherited from ObservableSanityClient.fetch
- Defined in src/SanityClient.ts:268
fetch<
    R = any,
    Q extends QueryWithoutParams | QueryParams = QueryParams,
    const G extends string = string,
>(
    query: G,
    params: Q extends QueryWithoutParams
        ? QueryWithoutParams
        : ClientParams<G, Q>,
    options: UnfilteredResponseWithoutQuery,
): Observable<RawQuerylessQueryResponse<ClientReturn<G, R>>>
Perform a GROQ-query against the configured dataset.
Type Parameters
- R = any
- Q extends QueryWithoutParams | QueryParams = QueryParams
- const G extends string = string
Parameters
- query: G
  GROQ-query to perform
- params: Q extends QueryWithoutParams ? QueryWithoutParams : ClientParams<G, Q>
  Optional query parameters
- options: UnfilteredResponseWithoutQuery
  Request options
Returns Observable<RawQuerylessQueryResponse<ClientReturn<G, R>>>
Inherited from ObservableSanityClient.fetch
- Defined in src/SanityClient.ts:284

getDocument

getDocument<R extends Record<string, any> = Record<string, any>>(
    id: string,
    options: {
        includeAllVersions: true;
        releaseId?: string;
        signal?: AbortSignal;
        tag?: string;
    },
): Observable<SanityDocument<R>[]>
Fetch a single document with the given ID.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- id: string
  Document ID to fetch
- options: {
      includeAllVersions: true;
      releaseId?: string;
      signal?: AbortSignal;
      tag?: string;
  }
  Request options
Returns Observable<SanityDocument<R>[]>
Inherited from ObservableSanityClient.getDocument
- Defined in src/SanityClient.ts:316
getDocument<R extends Record<string, any> = Record<string, any>>(
    id: string,
    options?: {
        includeAllVersions?: false;
        releaseId?: string;
        signal?: AbortSignal;
        tag?: string;
    },
): Observable<SanityDocument<R> | undefined>
Fetch a single document with the given ID.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- id: string
  Document ID to fetch
- Optionaloptions: {
      includeAllVersions?: false;
      releaseId?: string;
      signal?: AbortSignal;
      tag?: string;
  }
  Request options
Returns Observable<SanityDocument<R> | undefined>
Inherited from ObservableSanityClient.getDocument
- Defined in src/SanityClient.ts:331

getDocuments

getDocuments<R extends Record<string, any> = Record<string, any>>(
ids: string[],
options?: { tag?: string },
): Observable<(SanityDocument<R> | null)[]>
Fetch multiple documents in one request. Should be used sparingly - performing a query is usually a better option. The order/position of documents is preserved based on the original array of IDs. If any of the documents are missing, they will be replaced by a null entry in the returned array
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- ids: string[]
  Document IDs to fetch
- Optionaloptions: { tag?: string }
  Request options
Returns Observable<(SanityDocument<R> | null)[]>
Inherited from ObservableSanityClient.getDocuments
- Defined in src/SanityClient.ts:377

Methods - Mutations

action

action(
operations: Action | Action[],
options?: BaseActionOptions,
): Observable<SingleActionResult | MultipleActionResult>
Perform action operations against the configured dataset
Parameters
- operations: Action | Action[]
  Action operation(s) to execute
- Optionaloptions: BaseActionOptions
  Action options
Returns Observable<SingleActionResult | MultipleActionResult>
Inherited from ObservableSanityClient.action
- Defined in src/SanityClient.ts:1196

create

create<R extends Record<string, any> = Record<string, any>>(
document: SanityDocumentStub<R>,
options: FirstDocumentMutationOptions,
): Observable<SanityDocument<R>>
Create a document. Requires a _type property. If no _id is provided, it will be generated by the database. Returns an observable that resolves to the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: SanityDocumentStub<R>
  Document to create
- options: FirstDocumentMutationOptions
  Mutation options
Returns Observable<SanityDocument<R>>
Inherited from ObservableSanityClient.create
- Defined in src/SanityClient.ts:409
create<R extends Record<string, any> = Record<string, any>>(
document: SanityDocumentStub<R>,
options: AllDocumentsMutationOptions,
): Observable<SanityDocument<R>[]>
Create a document. Requires a _type property. If no _id is provided, it will be generated by the database. Returns an observable that resolves to an array containing the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: SanityDocumentStub<R>
  Document to create
- options: AllDocumentsMutationOptions
  Mutation options
Returns Observable<SanityDocument<R>[]>
Inherited from ObservableSanityClient.create
- Defined in src/SanityClient.ts:420
create<R extends Record<string, any> = Record<string, any>>(
document: SanityDocumentStub<R>,
options: FirstDocumentIdMutationOptions,
): Observable<SingleMutationResult>
Create a document. Requires a _type property. If no _id is provided, it will be generated by the database. Returns an observable that resolves to a mutation result object containing the ID of the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: SanityDocumentStub<R>
  Document to create
- options: FirstDocumentIdMutationOptions
  Mutation options
Returns Observable<SingleMutationResult>
Inherited from ObservableSanityClient.create
- Defined in src/SanityClient.ts:431
create<R extends Record<string, any> = Record<string, any>>(
document: SanityDocumentStub<R>,
options: AllDocumentIdsMutationOptions,
): Observable<MultipleMutationResult>
Create a document. Requires a _type property. If no _id is provided, it will be generated by the database. Returns an observable that resolves to a mutation result object containing the ID of the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: SanityDocumentStub<R>
  Document to create
- options: AllDocumentIdsMutationOptions
  Mutation options
Returns Observable<MultipleMutationResult>
Inherited from ObservableSanityClient.create
- Defined in src/SanityClient.ts:442
create<R extends Record<string, any> = Record<string, any>>(
document: SanityDocumentStub<R>,
options?: BaseMutationOptions,
): Observable<SanityDocument<R>>
Create a document. Requires a _type property. If no _id is provided, it will be generated by the database. Returns an observable that resolves to the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: SanityDocumentStub<R>
  Document to create
- Optionaloptions: BaseMutationOptions
  Mutation options
Returns Observable<SanityDocument<R>>
Inherited from ObservableSanityClient.create
- Defined in src/SanityClient.ts:453

createIfNotExists

createIfNotExists<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: FirstDocumentMutationOptions,
): Observable<SanityDocument<R>>
Create a document if no document with the same ID already exists. Returns an observable that resolves to the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: IdentifiedSanityDocumentStub<R>
  Document to create
- options: FirstDocumentMutationOptions
  Mutation options
Returns Observable<SanityDocument<R>>
Inherited from ObservableSanityClient.createIfNotExists
- Defined in src/SanityClient.ts:480
createIfNotExists<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: AllDocumentsMutationOptions,
): Observable<SanityDocument<R>[]>
Create a document if no document with the same ID already exists. Returns an observable that resolves to an array containing the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: IdentifiedSanityDocumentStub<R>
  Document to create
- options: AllDocumentsMutationOptions
  Mutation options
Returns Observable<SanityDocument<R>[]>
Inherited from ObservableSanityClient.createIfNotExists
- Defined in src/SanityClient.ts:491
createIfNotExists<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: FirstDocumentIdMutationOptions,
): Observable<SingleMutationResult>
Create a document if no document with the same ID already exists. Returns an observable that resolves to a mutation result object containing the ID of the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: IdentifiedSanityDocumentStub<R>
  Document to create
- options: FirstDocumentIdMutationOptions
  Mutation options
Returns Observable<SingleMutationResult>
Inherited from ObservableSanityClient.createIfNotExists
- Defined in src/SanityClient.ts:502
createIfNotExists<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: AllDocumentIdsMutationOptions,
): Observable<MultipleMutationResult>
Create a document if no document with the same ID already exists. Returns an observable that resolves to a mutation result object containing the ID of the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: IdentifiedSanityDocumentStub<R>
  Document to create
- options: AllDocumentIdsMutationOptions
  Mutation options
Returns Observable<MultipleMutationResult>
Inherited from ObservableSanityClient.createIfNotExists
- Defined in src/SanityClient.ts:513
createIfNotExists<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options?: BaseMutationOptions,
): Observable<SanityDocument<R>>
Create a document if no document with the same ID already exists. Returns an observable that resolves to the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: IdentifiedSanityDocumentStub<R>
  Document to create
- Optionaloptions: BaseMutationOptions
  Mutation options
Returns Observable<SanityDocument<R>>
Inherited from ObservableSanityClient.createIfNotExists
- Defined in src/SanityClient.ts:524

createOrReplace

createOrReplace<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: FirstDocumentMutationOptions,
): Observable<SanityDocument<R>>
Create a document if it does not exist, or replace a document with the same document ID Returns an observable that resolves to the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: IdentifiedSanityDocumentStub<R>
  Document to either create or replace
- options: FirstDocumentMutationOptions
  Mutation options
Returns Observable<SanityDocument<R>>
Inherited from ObservableSanityClient.createOrReplace
- Defined in src/SanityClient.ts:551
createOrReplace<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: AllDocumentsMutationOptions,
): Observable<SanityDocument<R>[]>
Create a document if it does not exist, or replace a document with the same document ID Returns an observable that resolves to an array containing the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: IdentifiedSanityDocumentStub<R>
  Document to either create or replace
- options: AllDocumentsMutationOptions
  Mutation options
Returns Observable<SanityDocument<R>[]>
Inherited from ObservableSanityClient.createOrReplace
- Defined in src/SanityClient.ts:562
createOrReplace<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: FirstDocumentIdMutationOptions,
): Observable<SingleMutationResult>
Create a document if it does not exist, or replace a document with the same document ID Returns an observable that resolves to a mutation result object containing the ID of the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: IdentifiedSanityDocumentStub<R>
  Document to either create or replace
- options: FirstDocumentIdMutationOptions
  Mutation options
Returns Observable<SingleMutationResult>
Inherited from ObservableSanityClient.createOrReplace
- Defined in src/SanityClient.ts:573
createOrReplace<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: AllDocumentIdsMutationOptions,
): Observable<MultipleMutationResult>
Create a document if it does not exist, or replace a document with the same document ID Returns an observable that resolves to a mutation result object containing the created document ID.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: IdentifiedSanityDocumentStub<R>
  Document to either create or replace
- options: AllDocumentIdsMutationOptions
  Mutation options
Returns Observable<MultipleMutationResult>
Inherited from ObservableSanityClient.createOrReplace
- Defined in src/SanityClient.ts:584
createOrReplace<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options?: BaseMutationOptions,
): Observable<SanityDocument<R>>
Create a document if it does not exist, or replace a document with the same document ID Returns an observable that resolves to the created document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- document: IdentifiedSanityDocumentStub<R>
  Document to either create or replace
- Optionaloptions: BaseMutationOptions
  Mutation options
Returns Observable<SanityDocument<R>>
Inherited from ObservableSanityClient.createOrReplace
- Defined in src/SanityClient.ts:595

delete

delete<R extends Record<string, any> = Record<string, any>>(
id: string,
options: FirstDocumentMutationOptions,
): Observable<SanityDocument<R>>
Deletes a document with the given document ID. Returns an observable that resolves to the deleted document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- id: string
  Document ID to delete
- options: FirstDocumentMutationOptions
  Options for the mutation
Returns Observable<SanityDocument<R>>
Inherited from ObservableSanityClient.delete
- Defined in src/SanityClient.ts:761
delete<R extends Record<string, any> = Record<string, any>>(
id: string,
options: AllDocumentsMutationOptions,
): Observable<SanityDocument<R>[]>
Deletes a document with the given document ID. Returns an observable that resolves to an array containing the deleted document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- id: string
  Document ID to delete
- options: AllDocumentsMutationOptions
  Options for the mutation
Returns Observable<SanityDocument<R>[]>
Inherited from ObservableSanityClient.delete
- Defined in src/SanityClient.ts:772
delete(
id: string,
options: FirstDocumentIdMutationOptions,
): Observable<SingleMutationResult>
Deletes a document with the given document ID. Returns an observable that resolves to a mutation result object containing the deleted document ID.
Parameters
- id: string
  Document ID to delete
- options: FirstDocumentIdMutationOptions
  Options for the mutation
Returns Observable<SingleMutationResult>
Inherited from ObservableSanityClient.delete
- Defined in src/SanityClient.ts:783
delete(
id: string,
options: AllDocumentIdsMutationOptions,
): Observable<MultipleMutationResult>
Deletes a document with the given document ID. Returns an observable that resolves to a mutation result object containing the deleted document ID.
Parameters
- id: string
  Document ID to delete
- options: AllDocumentIdsMutationOptions
  Options for the mutation
Returns Observable<MultipleMutationResult>
Inherited from ObservableSanityClient.delete
- Defined in src/SanityClient.ts:791
delete(
id: string,
options?: BaseMutationOptions,
): Observable<MultipleMutationResult>
Deletes a document with the given document ID. Returns an observable that resolves to a mutation result object containing the deleted document ID.
Parameters
- id: string
  Document ID to delete
- Optionaloptions: BaseMutationOptions
  Options for the mutation
Returns Observable<MultipleMutationResult>
Inherited from ObservableSanityClient.delete
- Defined in src/SanityClient.ts:799
delete<R extends Record<string, any> = Record<string, any>>(
selection: MutationSelection,
options: FirstDocumentMutationOptions,
): Observable<SanityDocument<R>>
Deletes one or more documents matching the given query or document ID. Returns an observable that resolves to first deleted document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- selection: MutationSelection
  An object with either an id or query key defining what to delete
- options: FirstDocumentMutationOptions
  Options for the mutation
Returns Observable<SanityDocument<R>>
Inherited from ObservableSanityClient.delete
- Defined in src/SanityClient.ts:807
delete<R extends Record<string, any> = Record<string, any>>(
selection: MutationSelection,
options: AllDocumentsMutationOptions,
): Observable<SanityDocument<R>[]>
Deletes one or more documents matching the given query or document ID. Returns an observable that resolves to an array containing the deleted documents.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- selection: MutationSelection
  An object with either an id or query key defining what to delete
- options: AllDocumentsMutationOptions
  Options for the mutation
Returns Observable<SanityDocument<R>[]>
Inherited from ObservableSanityClient.delete
- Defined in src/SanityClient.ts:818
delete(
selection: MutationSelection,
options: FirstDocumentIdMutationOptions,
): Observable<SingleMutationResult>
Deletes one or more documents matching the given query or document ID. Returns an observable that resolves to a mutation result object containing the ID of the first deleted document.
Parameters
- selection: MutationSelection
  An object with either an id or query key defining what to delete
- options: FirstDocumentIdMutationOptions
  Options for the mutation
Returns Observable<SingleMutationResult>
Inherited from ObservableSanityClient.delete
- Defined in src/SanityClient.ts:829
delete(
selection: MutationSelection,
options: AllDocumentIdsMutationOptions,
): Observable<MultipleMutationResult>
Deletes one or more documents matching the given query or document ID. Returns an observable that resolves to a mutation result object containing the document IDs that were deleted.
Parameters
- selection: MutationSelection
  An object with either an id or query key defining what to delete
- options: AllDocumentIdsMutationOptions
  Options for the mutation
Returns Observable<MultipleMutationResult>
Inherited from ObservableSanityClient.delete
- Defined in src/SanityClient.ts:840
delete(
selection: MutationSelection,
options?: BaseMutationOptions,
): Observable<MultipleMutationResult>
Deletes one or more documents matching the given query or document ID. Returns an observable that resolves to a mutation result object containing the document IDs that were deleted.
Parameters
- selection: MutationSelection
  An object with either an id or query key defining what to delete
- Optionaloptions: BaseMutationOptions
  Options for the mutation
Returns Observable<MultipleMutationResult>
Inherited from ObservableSanityClient.delete
- Defined in src/SanityClient.ts:851

mutate

mutate<R extends Record<string, any> = Record<string, any>>(
operations: Mutation<R>[] | ObservablePatch | ObservableTransaction,
options: FirstDocumentMutationOptions,
): Observable<SanityDocument<R>>
Perform mutation operations against the configured dataset Returns an observable that resolves to the first mutated document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- operations: Mutation<R>[] | ObservablePatch | ObservableTransaction
  Mutation operations to execute
- options: FirstDocumentMutationOptions
  Mutation options
Returns Observable<SanityDocument<R>>
Inherited from ObservableSanityClient.mutate
- Defined in src/SanityClient.ts:1073
mutate<R extends Record<string, any> = Record<string, any>>(
operations: ObservablePatch | ObservableTransaction | Mutation<R>[],
options: AllDocumentsMutationOptions,
): Observable<SanityDocument<R>[]>
Perform mutation operations against the configured dataset. Returns an observable that resolves to an array of the mutated documents.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- operations: ObservablePatch | ObservableTransaction | Mutation<R>[]
  Mutation operations to execute
- options: AllDocumentsMutationOptions
  Mutation options
Returns Observable<SanityDocument<R>[]>
Inherited from ObservableSanityClient.mutate
- Defined in src/SanityClient.ts:1084
mutate<R extends Record<string, any> = Record<string, any>>(
operations: ObservablePatch | ObservableTransaction | Mutation<R>[],
options: FirstDocumentIdMutationOptions,
): Observable<SingleMutationResult>
Perform mutation operations against the configured dataset Returns an observable that resolves to a mutation result object containing the document ID of the first mutated document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- operations: ObservablePatch | ObservableTransaction | Mutation<R>[]
  Mutation operations to execute
- options: FirstDocumentIdMutationOptions
  Mutation options
Returns Observable<SingleMutationResult>
Inherited from ObservableSanityClient.mutate
- Defined in src/SanityClient.ts:1095
mutate<R extends Record<string, any> = Record<string, any>>(
operations: ObservablePatch | ObservableTransaction | Mutation<R>[],
options: AllDocumentIdsMutationOptions,
): Observable<MultipleMutationResult>
Perform mutation operations against the configured dataset Returns an observable that resolves to a mutation result object containing the mutated document IDs.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- operations: ObservablePatch | ObservableTransaction | Mutation<R>[]
  Mutation operations to execute
- options: AllDocumentIdsMutationOptions
  Mutation options
Returns Observable<MultipleMutationResult>
Inherited from ObservableSanityClient.mutate
- Defined in src/SanityClient.ts:1106
mutate<R extends Record<string, any> = Record<string, any>>(
operations: ObservablePatch | ObservableTransaction | Mutation<R>[],
options?: BaseMutationOptions,
): Observable<MultipleMutationResult>
Perform mutation operations against the configured dataset Returns an observable that resolves to a mutation result object containing the mutated document IDs.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- operations: ObservablePatch | ObservableTransaction | Mutation<R>[]
  Mutation operations to execute
- Optionaloptions: BaseMutationOptions
  Mutation options
Returns Observable<MultipleMutationResult>
Inherited from ObservableSanityClient.mutate
- Defined in src/SanityClient.ts:1117

patch

patch(documentId: string, operations?: PatchOperations): ObservablePatch
Create a new buildable patch of operations to perform
Parameters
- documentId: string
  Document ID to patch
- Optionaloperations: PatchOperations
  Optional object of patch operations to initialize the patch instance with
Returns ObservablePatch
Patch instance - call .commit() to perform the operations defined
Inherited from ObservableSanityClient.patch
- Defined in src/SanityClient.ts:1144
patch(documentIds: string[], operations?: PatchOperations): ObservablePatch
Create a new buildable patch of operations to perform
Parameters
- documentIds: string[]
  Array of document IDs to patch
- Optionaloperations: PatchOperations
  Optional object of patch operations to initialize the patch instance with
Returns ObservablePatch
Patch instance - call .commit() to perform the operations defined
Inherited from ObservableSanityClient.patch
- Defined in src/SanityClient.ts:1153
patch(
selection: MutationSelection,
operations?: PatchOperations,
): ObservablePatch
Create a new buildable patch of operations to perform
Parameters
- selection: MutationSelection
  An object with query and optional params, defining which document(s) to patch
- Optionaloperations: PatchOperations
  Optional object of patch operations to initialize the patch instance with
Returns ObservablePatch
Patch instance - call .commit() to perform the operations defined
Inherited from ObservableSanityClient.patch
- Defined in src/SanityClient.ts:1162

transaction

transaction<R extends Record<string, any> = Record<string, any>>(
operations?: Mutation<R>[],
): ObservableTransaction
Create a new transaction of mutations
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- Optionaloperations: Mutation<R>[]
  Optional array of mutation operations to initialize the transaction instance with
Returns ObservableTransaction
Inherited from ObservableSanityClient.transaction
- Defined in src/SanityClient.ts:1182

Methods - Versions

createVersion

createVersion<R extends Record<string, any>>(
    args: {
        document: SanityDocumentStub<R>;
        publishedId: string;
        releaseId?: string;
    },
    options?: BaseActionOptions,
): Observable<SingleActionResult | MultipleActionResult>
Creates a new version of a published document.
Type Parameters
- R extends Record<string, any>
Parameters
- args: { document: SanityDocumentStub<R>; publishedId: string; releaseId?: string }
- Optionaloptions: BaseActionOptions
  Additional action options.
Returns Observable<SingleActionResult | MultipleActionResult>
an observable that resolves to the transactionId.
Remarks
- Requires a document with a _type property.
- Creating a version with no releaseId will create a new draft version of the published document.
- If the document._id is defined, it should be a draft or release version ID that matches the version ID generated from publishedId and releaseId.
- If the document._id is not defined, it will be generated from publishedId and releaseId.
- To create a version of an unpublished document, use the client.create method.
Example: Creating a new version of a published document with a generated version ID
```
client.observable.createVersion({
  // The document does not need to include an `_id` property since it will be generated from `publishedId` and `releaseId`
  document: {_type: 'myDocument', title: 'My Document'},
  publishedId: 'myDocument',
  releaseId: 'myRelease',
})

// The following document will be created:
// {
//   _id: 'versions.myRelease.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Example: Creating a new version of a published document with a specified version ID
```
client.observable.createVersion({
  document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
  // `publishedId` and `releaseId` are not required since `document._id` has been specified
})

// The following document will be created:
// {
//   _id: 'versions.myRelease.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Example: Creating a new draft version of a published document
```
client.observable.createVersion({
  document: {_type: 'myDocument', title: 'My Document'},
  publishedId: 'myDocument',
})

// The following document will be created:
// {
//   _id: 'drafts.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Inherited from ObservableSanityClient.createVersion
- Defined in src/SanityClient.ts:681
createVersion<R extends Record<string, any>>(
    args: {
        document: IdentifiedSanityDocumentStub<R>;
        publishedId?: string;
        releaseId?: string;
    },
    options?: BaseActionOptions,
): Observable<SingleActionResult | MultipleActionResult>
Creates a new version of a published document.
Type Parameters
- R extends Record<string, any>
Parameters
- args: {
      document: IdentifiedSanityDocumentStub<R>;
      publishedId?: string;
      releaseId?: string;
  }
- Optionaloptions: BaseActionOptions
  Additional action options.
Returns Observable<SingleActionResult | MultipleActionResult>
an observable that resolves to the transactionId.
Remarks
- Requires a document with a _type property.
- Creating a version with no releaseId will create a new draft version of the published document.
- If the document._id is defined, it should be a draft or release version ID that matches the version ID generated from publishedId and releaseId.
- If the document._id is not defined, it will be generated from publishedId and releaseId.
- To create a version of an unpublished document, use the client.create method.
Example: Creating a new version of a published document with a generated version ID
```
client.observable.createVersion({
  // The document does not need to include an `_id` property since it will be generated from `publishedId` and `releaseId`
  document: {_type: 'myDocument', title: 'My Document'},
  publishedId: 'myDocument',
  releaseId: 'myRelease',
})

// The following document will be created:
// {
//   _id: 'versions.myRelease.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Example: Creating a new version of a published document with a specified version ID
```
client.observable.createVersion({
  document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
  // `publishedId` and `releaseId` are not required since `document._id` has been specified
})

// The following document will be created:
// {
//   _id: 'versions.myRelease.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Example: Creating a new draft version of a published document
```
client.observable.createVersion({
  document: {_type: 'myDocument', title: 'My Document'},
  publishedId: 'myDocument',
})

// The following document will be created:
// {
//   _id: 'drafts.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Inherited from ObservableSanityClient.createVersion
- Defined in src/SanityClient.ts:689
createVersion(
    args: {
        baseId: string;
        ifBaseRevisionId?: string;
        publishedId: string;
        releaseId?: string;
    },
    options?: BaseActionOptions,
): Observable<SingleActionResult | MultipleActionResult>
Creates a new version of a published document.
Parameters
- args: {
      baseId: string;
      ifBaseRevisionId?: string;
      publishedId: string;
      releaseId?: string;
  }
- Optionaloptions: BaseActionOptions
  Additional action options.
Returns Observable<SingleActionResult | MultipleActionResult>
an observable that resolves to the transactionId.
Remarks
- Requires a document with a _type property.
- Creating a version with no releaseId will create a new draft version of the published document.
- If the document._id is defined, it should be a draft or release version ID that matches the version ID generated from publishedId and releaseId.
- If the document._id is not defined, it will be generated from publishedId and releaseId.
- To create a version of an unpublished document, use the client.create method.
Example: Creating a new version of a published document with a generated version ID
```
client.observable.createVersion({
  // The document does not need to include an `_id` property since it will be generated from `publishedId` and `releaseId`
  document: {_type: 'myDocument', title: 'My Document'},
  publishedId: 'myDocument',
  releaseId: 'myRelease',
})

// The following document will be created:
// {
//   _id: 'versions.myRelease.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Example: Creating a new version of a published document with a specified version ID
```
client.observable.createVersion({
  document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
  // `publishedId` and `releaseId` are not required since `document._id` has been specified
})

// The following document will be created:
// {
//   _id: 'versions.myRelease.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Example: Creating a new draft version of a published document
```
client.observable.createVersion({
  document: {_type: 'myDocument', title: 'My Document'},
  publishedId: 'myDocument',
})

// The following document will be created:
// {
//   _id: 'drafts.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Inherited from ObservableSanityClient.createVersion
- Defined in src/SanityClient.ts:697

discardVersion

discardVersion(
    params: { publishedId: string; releaseId?: string },
    purge?: boolean,
    options?: BaseActionOptions,
): Observable<SingleActionResult | MultipleActionResult>
Deletes the draft or release version of a document.
Parameters
- params: { publishedId: string; releaseId?: string }
  Version action parameters:
  
  releaseId - The ID of the release to discard the document from.
  
  publishedId - The published ID of the document to discard.
- Optionalpurge: boolean
  if true the document history is also discarded.
- Optionaloptions: BaseActionOptions
  Additional action options.
Returns Observable<SingleActionResult | MultipleActionResult>
an observable that resolves to the transactionId.
Remarks
- Discarding a version with no releaseId will discard the draft version of the published document.
- If the draft or release version does not exist, any error will throw.
Example: Discarding a release version of a document
```
client.observable.discardVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
// The document with the ID `versions.myRelease.myDocument` will be discarded.
```
Example: Discarding a draft version of a document
```
client.observable.discardVersion({publishedId: 'myDocument'})
// The document with the ID `drafts.myDocument` will be discarded.
```
Inherited from ObservableSanityClient.discardVersion
- Defined in src/SanityClient.ts:899

replaceVersion

replaceVersion<R extends Record<string, any>>(
    args: {
        document: SanityDocumentStub<R>;
        publishedId: string;
        releaseId?: string;
    },
    options?: BaseActionOptions,
): Observable<SingleActionResult | MultipleActionResult>
Replaces an existing version document.
Type Parameters
- R extends Record<string, any>
Parameters
- args: { document: SanityDocumentStub<R>; publishedId: string; releaseId?: string }
- Optionaloptions: BaseActionOptions
  Additional action options.
Returns Observable<SingleActionResult | MultipleActionResult>
an observable that resolves to the transactionId.
Remarks
- Requires a document with a _type property.
- If the document._id is defined, it should be a draft or release version ID that matches the version ID generated from publishedId and releaseId.
- If the document._id is not defined, it will be generated from publishedId and releaseId.
- Replacing a version with no releaseId will replace the draft version of the published document.
- At least one of the version or published documents must exist.
Example: Replacing a release version of a published document with a generated version ID
```
client.observable.replaceVersion({
  document: {_type: 'myDocument', title: 'My Document'},
  publishedId: 'myDocument',
  releaseId: 'myRelease',
})

// The following document will be patched:
// {
//   _id: 'versions.myRelease.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Example: Replacing a release version of a published document with a specified version ID
```
client.observable.replaceVersion({
  document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
  // `publishedId` and `releaseId` are not required since `document._id` has been specified
})

// The following document will be patched:
// {
//   _id: 'versions.myRelease.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Example: Replacing a draft version of a published document
```
client.observable.replaceVersion({
  document: {_type: 'myDocument', title: 'My Document'},
  publishedId: 'myDocument',
})

// The following document will be patched:
// {
//   _id: 'drafts.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Inherited from ObservableSanityClient.replaceVersion
- Defined in src/SanityClient.ts:982
replaceVersion<R extends Record<string, any>>(
    args: {
        document: IdentifiedSanityDocumentStub<R>;
        publishedId?: string;
        releaseId?: string;
    },
    options?: BaseActionOptions,
): Observable<SingleActionResult | MultipleActionResult>
Replaces an existing version document.
Type Parameters
- R extends Record<string, any>
Parameters
- args: {
      document: IdentifiedSanityDocumentStub<R>;
      publishedId?: string;
      releaseId?: string;
  }
- Optionaloptions: BaseActionOptions
  Additional action options.
Returns Observable<SingleActionResult | MultipleActionResult>
an observable that resolves to the transactionId.
Remarks
- Requires a document with a _type property.
- If the document._id is defined, it should be a draft or release version ID that matches the version ID generated from publishedId and releaseId.
- If the document._id is not defined, it will be generated from publishedId and releaseId.
- Replacing a version with no releaseId will replace the draft version of the published document.
- At least one of the version or published documents must exist.
Example: Replacing a release version of a published document with a generated version ID
```
client.observable.replaceVersion({
  document: {_type: 'myDocument', title: 'My Document'},
  publishedId: 'myDocument',
  releaseId: 'myRelease',
})

// The following document will be patched:
// {
//   _id: 'versions.myRelease.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Example: Replacing a release version of a published document with a specified version ID
```
client.observable.replaceVersion({
  document: {_type: 'myDocument', _id: 'versions.myRelease.myDocument', title: 'My Document'},
  // `publishedId` and `releaseId` are not required since `document._id` has been specified
})

// The following document will be patched:
// {
//   _id: 'versions.myRelease.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Example: Replacing a draft version of a published document
```
client.observable.replaceVersion({
  document: {_type: 'myDocument', title: 'My Document'},
  publishedId: 'myDocument',
})

// The following document will be patched:
// {
//   _id: 'drafts.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Inherited from ObservableSanityClient.replaceVersion
- Defined in src/SanityClient.ts:990

unpublishVersion

unpublishVersion(
params: { publishedId: string; releaseId: string },
options?: BaseActionOptions,
): Observable<SingleActionResult | MultipleActionResult>
Used to indicate when a document within a release should be unpublished when the release is run.
Parameters
- params: { publishedId: string; releaseId: string }
  Version action parameters:
  
  releaseId - The ID of the release to unpublish the document from.
  
  publishedId - The published ID of the document to unpublish.
- Optionaloptions: BaseActionOptions
  Additional action options.
Returns Observable<SingleActionResult | MultipleActionResult>
an observable that resolves to the transactionId.
Remarks
- If the published document does not exist, an error will be thrown.
Example: Unpublishing a release version of a published document
```
client.observable.unpublishVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
// The document with the ID `versions.myRelease.myDocument` will be unpublished. when `myRelease` is run.
```
Inherited from ObservableSanityClient.unpublishVersion
- Defined in src/SanityClient.ts:1049

Methods - HTTP

getDataUrl

getDataUrl(operation: string, path?: string): string
Get a Sanity API URL for the data operation and path provided
Parameters
- operation: string
  Data operation (eg query, mutate, listen or similar)
- Optionalpath: string
  Path to append after the operation
Returns string
Inherited from ObservableSanityClient.getDataUrl
- Defined in src/SanityClient.ts:1234

getUrl

getUrl(uri: string, canUseCdn?: boolean): string
Get a Sanity API URL for the URI provided
Parameters
- uri: string
  URI/path to build URL for
- OptionalcanUseCdn: boolean
  Whether or not to allow using the API CDN for this route
Returns string
Inherited from ObservableSanityClient.getUrl
- Defined in src/SanityClient.ts:1222

request

request<R = any>(options: RawRequestOptions): Observable<R>
Perform an HTTP request against the Sanity API
Type Parameters
- R = any
Parameters
- options: RawRequestOptions
  Request options
Returns Observable<R>
Inherited from ObservableSanityClient.request
- Defined in src/SanityClient.ts:1210

Class ObservableSanityStegaClient

Deprecated

Hierarchy (View Summary)

Index

Constructors

Properties - Releases

Properties - Assets

Properties - Agent Actions

Properties - Real-time

Properties - Projects & Datasets

Properties - Other

Methods - Configuration

Methods - Querying

Methods - Mutations

Methods - Versions

Methods - HTTP

Constructors

constructor

Parameters

Returns ObservableSanityStegaClient

Properties - Releases

releases

Type declaration

archive: function

Parameters

Returns Observable<SingleActionResult>

create: function

Parameters

Returns Observable< SingleActionResult & { metadata: { cardinality?: ReleaseCardinality; description?: string; intendedPublishAt?: string; releaseType: ReleaseType; title?: string; }; releaseId: string; },>

Remarks

Example: Creating a release with a custom id and metadata

Example: Creating a release with generated id and metadata

Example: Creating a release using a custom transaction id

Parameters

Returns Observable< SingleActionResult & { metadata: { cardinality?: ReleaseCardinality; description?: string; intendedPublishAt?: string; releaseType: ReleaseType; title?: string; }; releaseId: string; },>

Remarks

Example: Creating a release with a custom id and metadata

Example: Creating a release with generated id and metadata

Example: Creating a release using a custom transaction id

delete: function

Parameters

Returns Observable<SingleActionResult>

edit: function

Parameters

Returns Observable<SingleActionResult>

fetchDocuments: function

Parameters

Returns Observable<RawQueryResponse<SanityDocument[]>>

get: function

Parameters

Returns Observable<ReleaseDocument | undefined>

Example: Retrieving a release by id

publish: function

Parameters

Returns Observable<SingleActionResult>

schedule: function

Parameters

Returns Observable<SingleActionResult>

unarchive: function

Parameters

Returns Observable<SingleActionResult>

unschedule: function

Parameters

Returns Observable<SingleActionResult>

Properties - Assets

assets

Type declaration

upload: function

Parameters

Returns Observable<UploadEvent<{ document: SanityAssetDocument }>>

Parameters

Returns Observable<UploadEvent<{ document: SanityImageAssetDocument }>>

Parameters

Returns Observable< UploadEvent< { document: SanityAssetDocument | SanityImageAssetDocument }, >,>

mediaLibrary

Type declaration

video: { getPlaybackInfo( assetIdentifier: MediaLibraryAssetInstanceIdentifier, options?: MediaLibraryPlaybackInfoOptions, ): Observable< VideoPlaybackInfo< VideoPlaybackInfoItem, VideoRenditionInfo, VideoSubtitleInfo, >, >;}

getPlaybackInfo: function

Parameters

Returns Observable< VideoPlaybackInfo< VideoPlaybackInfoItem, VideoRenditionInfo, VideoSubtitleInfo, >,>

Returns Observable<
SingleActionResult & {
metadata: {
cardinality?: ReleaseCardinality;
description?: string;
intendedPublishAt?: string;
releaseType: ReleaseType;
title?: string;
};
releaseId: string;
},
>

Returns Observable<
SingleActionResult & {
metadata: {
cardinality?: ReleaseCardinality;
description?: string;
intendedPublishAt?: string;
releaseType: ReleaseType;
title?: string;
};
releaseId: string;
},
>

Returns Observable<
UploadEvent<
{ document: SanityAssetDocument
| SanityImageAssetDocument },
>,
>

video: {
getPlaybackInfo(
assetIdentifier: MediaLibraryAssetInstanceIdentifier,
options?: MediaLibraryPlaybackInfoOptions,
): Observable<
VideoPlaybackInfo<
VideoPlaybackInfoItem,
VideoRenditionInfo,
VideoSubtitleInfo,
>,
>;
}

Returns Observable<
VideoPlaybackInfo<
VideoPlaybackInfoItem,
VideoRenditionInfo,
VideoSubtitleInfo,
>,
>

Returns Observable<
{ [key: string]: any } & { _id: string } & { [key: string]: any } & {
_type: string;
} & DocumentShape,
>

Returns Observable<
{ [key: string]: any } & { _id: string } & { [key: string]: any } & {
_type: string;
} & DocumentShape,
>

Returns Observable<
{ [key: string]: any } & { _id: string } & { [key: string]: any } & {
_type: string;
} & DocumentShape,
>

`Optional`includeDrafts?: boolean

`Optional`tag?: string

`Optional`waitFor?: "function"