Class SanityStegaClient

Deprecated

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

Hierarchy (View Summary)

SanityClient
- SanityStegaClient

Index

Constructors

constructor

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

Properties - Configuration

observable

observable: ObservableSanityClient

Observable version of the Sanity client, with the same configuration as the promise-based one

Properties - Releases

releases

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

Create and manage content releases and their scheduled publishing

Type declaration

archive: function
- archive(
  params: { releaseId: string },
  options?: BaseActionOptions,
  ): Promise<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 Promise<SingleActionResult>
  A promise that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:560
create: function
- create(
      options: BaseActionOptions,
  ): Promise<
      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 Promise<
      SingleActionResult & {
          metadata: {
              cardinality?: ReleaseCardinality;
              description?: string;
              intendedPublishAt?: string;
              releaseType: ReleaseType;
              title?: string;
          };
          releaseId: string;
      },
  >
  A promise 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 releaseMetadata: ReleaseDocument['metadata'] = { releaseType: 'asap', } const result = await client.releases.create({releaseId, metadata: releaseMetadata}) console.log(result) // { // transactionId: 'transaction-id', // releaseId: 'my-release', // metadata: {releaseType: 'asap'}, // }
  Example: Creating a release with generated id and metadata
  const {metadata} = await client.releases.create() console.log(metadata.releaseType) // 'undecided'
  Example: Creating a release with a custom transaction id
  const {transactionId, metadata} = await client.releases.create({transactionId: 'my-transaction-id'}) console.log(metadata.releaseType) // 'undecided' console.log(transactionId) // 'my-transaction-id'
  - Defined in src/releases/ReleasesClient.ts:468
- create(
      release: {
          metadata?: Partial<
              {
                  cardinality?: ReleaseCardinality;
                  description?: string;
                  intendedPublishAt?: string;
                  releaseType: ReleaseType;
                  title?: string;
              },
          >;
          releaseId?: string;
      },
      options?: BaseActionOptions,
  ): Promise<
      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 Promise<
      SingleActionResult & {
          metadata: {
              cardinality?: ReleaseCardinality;
              description?: string;
              intendedPublishAt?: string;
              releaseType: ReleaseType;
              title?: string;
          };
          releaseId: string;
      },
  >
  A promise 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 releaseMetadata: ReleaseDocument['metadata'] = { releaseType: 'asap', } const result = await client.releases.create({releaseId, metadata: releaseMetadata}) console.log(result) // { // transactionId: 'transaction-id', // releaseId: 'my-release', // metadata: {releaseType: 'asap'}, // }
  Example: Creating a release with generated id and metadata
  const {metadata} = await client.releases.create() console.log(metadata.releaseType) // 'undecided'
  Example: Creating a release with a custom transaction id
  const {transactionId, metadata} = await client.releases.create({transactionId: 'my-transaction-id'}) console.log(metadata.releaseType) // 'undecided' console.log(transactionId) // 'my-transaction-id'
  - Defined in src/releases/ReleasesClient.ts:471
delete: function
- delete(
  params: { releaseId: string },
  options?: BaseActionOptions,
  ): Promise<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 Promise<SingleActionResult>
  A promise that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:666
edit: function
- edit(
  params: { patch: PatchOperations; releaseId: string },
  options?: BaseActionOptions,
  ): Promise<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 Promise<SingleActionResult>
  A promise that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:502
fetchDocuments: function
- fetchDocuments(
  params: { releaseId: string },
  options?: BaseMutationOptions,
  ): Promise<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 Promise<RawQueryResponse<SanityDocument[]>>
  A promise that resolves to the documents in the release.
  - Defined in src/releases/ReleasesClient.ts:690
get: function
- get(
  params: { releaseId: string },
  options?: { signal?: AbortSignal; tag?: string },
  ): Promise<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 Promise<ReleaseDocument | undefined>
  A promise that resolves to the release document ReleaseDocument.
  Example: Retrieving a release by id
  const release = await client.releases.get({releaseId: 'my-release'}) console.log(release) // { // _id: '_.releases.my-release', // name: 'my-release' // _type: 'system.release', // metadata: {releaseType: 'asap'}, // _createdAt: '2021-01-01T00:00:00.000Z', // ... // }
  - Defined in src/releases/ReleasesClient.ts:409
publish: function
- publish(
  params: { releaseId: string },
  options?: BaseActionOptions,
  ): Promise<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 Promise<SingleActionResult>
  A promise that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:533
schedule: function
- schedule(
  params: { publishAt: string; releaseId: string },
  options?: BaseActionOptions,
  ): Promise<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 Promise<SingleActionResult>
  A promise that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:613
unarchive: function
- unarchive(
  params: { releaseId: string },
  options?: BaseActionOptions,
  ): Promise<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 Promise<SingleActionResult>
  A promise that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:585
unschedule: function
- unschedule(
  params: { releaseId: string },
  options?: BaseActionOptions,
  ): Promise<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 Promise<SingleActionResult>
  A promise that resolves to the transactionId.
  - Defined in src/releases/ReleasesClient.ts:641

Properties - Assets

assets

assets: {
    upload(
        assetType: "file",
        body: UploadBody,
        options?: UploadClientConfig,
    ): Promise<SanityAssetDocument>;
    upload(
        assetType: "image",
        body: UploadBody,
        options?: UploadClientConfig,
    ): Promise<SanityImageAssetDocument>;
    upload(
        assetType: "file" | "image",
        body: UploadBody,
        options?: UploadClientConfig,
    ): Promise<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,
  ): Promise<SanityAssetDocument>
  Uploads a file asset to the configured dataset
  
  Note: when the client is configured against a Media Library (resource: {type: 'media-library', id}), this resolves to a MediaLibraryAssetDocument at runtime, not to a SanityAssetDocument. The declared type cannot express that: the shape depends on the client's configuration rather than on the arguments, so an overload cannot discriminate it, and widening the return type into a union would be a breaking change for every existing caller. Narrow the result yourself (for example, check for currentVersion) if you upload to a Media Library. Typing this honestly is deferred to the next major.
  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 Promise<SanityAssetDocument>
  - Defined in src/assets/AssetsClient.ts:113
- upload(
      assetType: "image",
      body: UploadBody,
      options?: UploadClientConfig,
  ): Promise<SanityImageAssetDocument>
  Uploads an image asset to the configured dataset
  
  Note: against a Media Library this resolves to a MediaLibraryAssetDocument at runtime. See the 'file' overload above for why the declared type cannot say so.
  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 Promise<SanityImageAssetDocument>
  - Defined in src/assets/AssetsClient.ts:129
- upload(
      assetType: "file" | "image",
      body: UploadBody,
      options?: UploadClientConfig,
  ): Promise<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 Promise<SanityAssetDocument | SanityImageAssetDocument>
  - Defined in src/assets/AssetsClient.ts:141

mediaLibrary

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

Interact with Media Library assets

Type declaration

video: {
    getPlaybackInfo(
        assetIdentifier: MediaLibraryAssetInstanceIdentifier,
        options?: MediaLibraryPlaybackInfoOptions,
    ): Promise<
        VideoPlaybackInfo<
            VideoPlaybackInfoItem,
            VideoRenditionInfo,
            VideoSubtitleInfo,
        >,
    >;
}
Upload and manage Media Library video assets
- getPlaybackInfo: function
  - getPlaybackInfo(
        assetIdentifier: MediaLibraryAssetInstanceIdentifier,
        options?: MediaLibraryPlaybackInfoOptions,
    ): Promise<
        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 Promise<
        VideoPlaybackInfo<
            VideoPlaybackInfoItem,
            VideoRenditionInfo,
            VideoSubtitleInfo,
        >,
    >
    Defined in src/mediaLibrary/MediaLibraryVideoClient.ts:77

Properties - Agent Actions

agent

agent: {
    action: {
        generate<DocumentShape extends Record<string, any>>(
            request: GenerateInstruction<DocumentShape>,
        ): Promise<
            { [key: string]: any } & { _id: string } & { [key: string]: any } & {
                _type: string;
            } & DocumentShape,
        >;
        patch<DocumentShape extends Record<string, any>>(
            request: PatchDocument<DocumentShape>,
        ): Promise<
            { [key: string]: any } & { _id: string } & { [key: string]: any } & {
                _type: string;
            } & DocumentShape,
        >;
        prompt<const DocumentShape extends Record<string, any>>(
            request: PromptRequest<DocumentShape>,
        ): Promise<string>;
        transform<DocumentShape extends Record<string, any>>(
            request: TransformDocument<T>,
        ): Promise<
            { [key: string]: any } & { _id: string } & { [key: string]: any } & {
                _type: string;
            } & DocumentShape,
        >;
        translate<DocumentShape extends Record<string, any>>(
            request: TranslateDocument<T>,
        ): Promise<
            { [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>,
    ): Promise<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >;
    patch<DocumentShape extends Record<string, any>>(
        request: PatchDocument<DocumentShape>,
    ): Promise<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >;
    prompt<const DocumentShape extends Record<string, any>>(
        request: PromptRequest<DocumentShape>,
    ): Promise<string>;
    transform<DocumentShape extends Record<string, any>>(
        request: TransformDocument<T>,
    ): Promise<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >;
    translate<DocumentShape extends Record<string, any>>(
        request: TranslateDocument<T>,
    ): Promise<
        { [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>,
    ): Promise<
        { [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 Promise<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >
    Defined in src/agent/actions/AgentActionsClient.ts:82
- patch: function
  - patch<DocumentShape extends Record<string, any>>(
        request: PatchDocument<DocumentShape>,
    ): Promise<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >
    Patch a document using a schema aware API. Does not use an LLM, but uses the schema to ensure paths and values matches the schema.
    Type Parameters
    DocumentShape extends Record<string, any>
    Parameters
    request: PatchDocument<DocumentShape>
    instruction request
    Returns Promise<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >
    Defined in src/agent/actions/AgentActionsClient.ts:135
- prompt: function
  - prompt<const DocumentShape extends Record<string, any>>(
    request: PromptRequest<DocumentShape>,
    ): Promise<string>
    Run a raw instruction and return the result either as text or json
    Type Parameters
    const DocumentShape extends Record<string, any>
    Parameters
    request: PromptRequest<DocumentShape>
    prompt request
    Returns Promise<string>
    Defined in src/agent/actions/AgentActionsClient.ts:124
- transform: function
  - transform<DocumentShape extends Record<string, any>>(
        request: TransformDocument<T>,
    ): Promise<
        { [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 Promise<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >
    Defined in src/agent/actions/AgentActionsClient.ts:96
- translate: function
  - translate<DocumentShape extends Record<string, any>>(
        request: TranslateDocument<T>,
    ): Promise<
        { [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 Promise<
        { [key: string]: any } & { _id: string } & { [key: string]: any } & {
            _type: string;
        } & DocumentShape,
    >
    Defined in src/agent/actions/AgentActionsClient.ts:110

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,
    ): Promise<DatasetResponse>;
    delete(name: string): Promise<{ deleted: true }>;
    edit(name: string, options?: DatasetEditOptions): Promise<DatasetResponse>;
    editEmbeddingsSettings(
        name: string,
        settings: EmbeddingsSettingsBody,
    ): Promise<void>;
    getEmbeddingsSettings(name: string): Promise<EmbeddingsSettings>;
    list(): Promise<DatasetsResponse>;
}

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

Type declaration

create: function
- create(name: string, options?: DatasetCreateOptions): Promise<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 Promise<DatasetResponse>
  - Defined in src/datasets/DatasetsClient.ts:131
delete: function
- delete(name: string): Promise<{ deleted: true }>
  Delete a dataset with the given name
  Parameters
  - name: string
    Name of the dataset to delete
  Returns Promise<{ deleted: true }>
  - Defined in src/datasets/DatasetsClient.ts:152
edit: function
- edit(name: string, options?: DatasetEditOptions): Promise<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 Promise<DatasetResponse>
  - Defined in src/datasets/DatasetsClient.ts:142
editEmbeddingsSettings: function
- editEmbeddingsSettings(
  name: string,
  settings: EmbeddingsSettingsBody,
  ): Promise<void>
  Edit embeddings settings for a dataset
  Parameters
  - name: string
    Name of the dataset
  - settings: EmbeddingsSettingsBody
    Embeddings settings to apply
  Returns Promise<void>
  - Defined in src/datasets/DatasetsClient.ts:195
getEmbeddingsSettings: function
- getEmbeddingsSettings(name: string): Promise<EmbeddingsSettings>
  Get embeddings settings for a dataset
  Parameters
  - name: string
    Name of the dataset
  Returns Promise<EmbeddingsSettings>
  - Defined in src/datasets/DatasetsClient.ts:180
list: function
- list(): Promise<DatasetsResponse>
  Fetch a list of datasets for the configured project
  
  Returns Promise<DatasetsResponse>
  - Defined in src/datasets/DatasetsClient.ts:160

projects

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

Fetch information about the projects the authenticated user has access to

Type declaration

getById: function
- getById(projectId: string): Promise<SanityProject>
  Fetch a project by project ID
  Parameters
  - projectId: string
    ID of the project to fetch
  Returns Promise<SanityProject>
  - Defined in src/projects/ProjectsClient.ts:124
list: function
- list<T extends ListOptions>(
  options?: T,
  ): Promise<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 Promise<Omit<SanityProject, OmittedProjectFields<T>>[]>
  - Defined in src/projects/ProjectsClient.ts:96

users

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

Fetch information about users in the configured project

Type declaration

getById: function
- getById<T extends string>(
  id: T,
  ): Promise<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 Promise<T extends "me" ? CurrentSanityUser : SanityUser>
  - Defined in src/users/UsersClient.ts:50

Properties - Other

collaboration

collaboration: { comments: CollaborationCommentsClient }

`Beta`context

context: ContextClient

functions

functions: FunctionsClient

Methods - Configuration

clone

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

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

config

config(): InitializedClientConfig
Returns the current client configuration

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

withConfig

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

Methods - Querying

documentsExists

documentsExists(
ids: string[],
options?: { signal?: AbortSignal; tag?: string },
): Promise<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 Promise<Set<string>>
Inherited from SanityClient.documentsExists
- Defined in src/SanityClient.ts:1565

fetch

fetch<
    R = any,
    Q extends QueryWithoutParams = QueryWithoutParams,
    const G extends string = string,
>(
    query: G,
    params?: QueryWithoutParams | Q,
): Promise<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 Promise<ClientReturn<G, R>>
Inherited from SanityClient.fetch
- Defined in src/SanityClient.ts:1412
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,
): Promise<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 Promise<ClientReturn<G, R>>
Inherited from SanityClient.fetch
- Defined in src/SanityClient.ts:1424
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,
): Promise<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 Promise<RawQueryResponse<ClientReturn<G, R>>>
Inherited from SanityClient.fetch
- Defined in src/SanityClient.ts:1440
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,
): Promise<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 Promise<RawQuerylessQueryResponse<ClientReturn<G, R>>>
Inherited from SanityClient.fetch
- Defined in src/SanityClient.ts:1456

getDocument

getDocument<R extends Record<string, any> = Record<string, any>>(
    id: string,
    options: {
        includeAllVersions: true;
        releaseId?: string;
        signal?: AbortSignal;
        tag?: string;
    },
): Promise<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 Promise<SanityDocument<R>[]>
Inherited from SanityClient.getDocument
- Defined in src/SanityClient.ts:1488
getDocument<R extends Record<string, any> = Record<string, any>>(
    id: string,
    options?: {
        includeAllVersions?: false;
        releaseId?: string;
        signal?: AbortSignal;
        tag?: string;
    },
): Promise<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 Promise<SanityDocument<R> | undefined>
Inherited from SanityClient.getDocument
- Defined in src/SanityClient.ts:1503

getDocuments

getDocuments<R extends Record<string, any> = Record<string, any>>(
ids: string[],
options?: { signal?: AbortSignal; tag?: string },
): Promise<(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: { signal?: AbortSignal; tag?: string }
  Request options
Returns Promise<(SanityDocument<R> | null)[]>
Inherited from SanityClient.getDocuments
- Defined in src/SanityClient.ts:1549

Methods - Mutations

action

action(
operations: Action | Action[],
options?: BaseActionOptions,
): Promise<SingleActionResult | MultipleActionResult>
Perform action operations against the configured dataset Returns a promise that resolves to the transaction result
Parameters
- operations: Action | Action[]
  Action operation(s) to execute
- Optionaloptions: BaseActionOptions
  Action options
Returns Promise<SingleActionResult | MultipleActionResult>
Inherited from SanityClient.action
- Defined in src/SanityClient.ts:2340

create

create<R extends Record<string, any> = Record<string, any>>(
document: SanityDocumentStub<R>,
options: FirstDocumentMutationOptions,
): Promise<SanityDocument<R>>
Create a document. Requires a _type property. If no _id is provided, it will be generated by the database. Returns a promise 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 Promise<SanityDocument<R>>
Inherited from SanityClient.create
- Defined in src/SanityClient.ts:1581
create<R extends Record<string, any> = Record<string, any>>(
document: SanityDocumentStub<R>,
options: AllDocumentsMutationOptions,
): Promise<SanityDocument<R>[]>
Create a document. Requires a _type property. If no _id is provided, it will be generated by the database. Returns a promise 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 Promise<SanityDocument<R>[]>
Inherited from SanityClient.create
- Defined in src/SanityClient.ts:1592
create<R extends Record<string, any> = Record<string, any>>(
document: SanityDocumentStub<R>,
options: FirstDocumentIdMutationOptions,
): Promise<SingleMutationResult>
Create a document. Requires a _type property. If no _id is provided, it will be generated by the database. Returns a promise 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 Promise<SingleMutationResult>
Inherited from SanityClient.create
- Defined in src/SanityClient.ts:1603
create<R extends Record<string, any> = Record<string, any>>(
document: SanityDocumentStub<R>,
options: AllDocumentIdsMutationOptions,
): Promise<MultipleMutationResult>
Create a document. Requires a _type property. If no _id is provided, it will be generated by the database. Returns a promise 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 Promise<MultipleMutationResult>
Inherited from SanityClient.create
- Defined in src/SanityClient.ts:1614
create<R extends Record<string, any> = Record<string, any>>(
document: SanityDocumentStub<R>,
options?: BaseMutationOptions,
): Promise<SanityDocument<R>>
Create a document. Requires a _type property. If no _id is provided, it will be generated by the database. Returns a promise 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 Promise<SanityDocument<R>>
Inherited from SanityClient.create
- Defined in src/SanityClient.ts:1625

createIfNotExists

createIfNotExists<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: FirstDocumentMutationOptions,
): Promise<SanityDocument<R>>
Create a document if no document with the same ID already exists. Returns a promise 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 Promise<SanityDocument<R>>
Inherited from SanityClient.createIfNotExists
- Defined in src/SanityClient.ts:1652
createIfNotExists<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: AllDocumentsMutationOptions,
): Promise<SanityDocument<R>[]>
Create a document if no document with the same ID already exists. Returns a promise 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 Promise<SanityDocument<R>[]>
Inherited from SanityClient.createIfNotExists
- Defined in src/SanityClient.ts:1663
createIfNotExists<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: FirstDocumentIdMutationOptions,
): Promise<SingleMutationResult>
Create a document if no document with the same ID already exists. Returns a promise 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 Promise<SingleMutationResult>
Inherited from SanityClient.createIfNotExists
- Defined in src/SanityClient.ts:1674
createIfNotExists<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: AllDocumentIdsMutationOptions,
): Promise<MultipleMutationResult>
Create a document if no document with the same ID already exists. Returns a promise 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 Promise<MultipleMutationResult>
Inherited from SanityClient.createIfNotExists
- Defined in src/SanityClient.ts:1685
createIfNotExists<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options?: BaseMutationOptions,
): Promise<SanityDocument<R>>
Create a document if no document with the same ID already exists. Returns a promise 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 Promise<SanityDocument<R>>
Inherited from SanityClient.createIfNotExists
- Defined in src/SanityClient.ts:1696

createOrReplace

createOrReplace<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: FirstDocumentMutationOptions,
): Promise<SanityDocument<R>>
Create a document if it does not exist, or replace a document with the same document ID Returns a promise 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 Promise<SanityDocument<R>>
Inherited from SanityClient.createOrReplace
- Defined in src/SanityClient.ts:1723
createOrReplace<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: AllDocumentsMutationOptions,
): Promise<SanityDocument<R>[]>
Create a document if it does not exist, or replace a document with the same document ID Returns a promise 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 Promise<SanityDocument<R>[]>
Inherited from SanityClient.createOrReplace
- Defined in src/SanityClient.ts:1734
createOrReplace<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: FirstDocumentIdMutationOptions,
): Promise<SingleMutationResult>
Create a document if it does not exist, or replace a document with the same document ID Returns a promise 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 Promise<SingleMutationResult>
Inherited from SanityClient.createOrReplace
- Defined in src/SanityClient.ts:1745
createOrReplace<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options: AllDocumentIdsMutationOptions,
): Promise<MultipleMutationResult>
Create a document if it does not exist, or replace a document with the same document ID Returns a promise 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 Promise<MultipleMutationResult>
Inherited from SanityClient.createOrReplace
- Defined in src/SanityClient.ts:1756
createOrReplace<R extends Record<string, any> = Record<string, any>>(
document: IdentifiedSanityDocumentStub<R>,
options?: BaseMutationOptions,
): Promise<SanityDocument<R>>
Create a document if it does not exist, or replace a document with the same document ID Returns a promise 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 Promise<SanityDocument<R>>
Inherited from SanityClient.createOrReplace
- Defined in src/SanityClient.ts:1767

delete

delete<R extends Record<string, any> = Record<string, any>>(
id: string,
options: FirstDocumentMutationOptions,
): Promise<SanityDocument<R>>
Deletes a document with the given document ID. Returns a promise 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 Promise<SanityDocument<R>>
Inherited from SanityClient.delete
- Defined in src/SanityClient.ts:1921
delete<R extends Record<string, any> = Record<string, any>>(
id: string,
options: AllDocumentsMutationOptions,
): Promise<SanityDocument<R>[]>
Deletes a document with the given document ID. Returns a promise 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 Promise<SanityDocument<R>[]>
Inherited from SanityClient.delete
- Defined in src/SanityClient.ts:1932
delete(
id: string,
options: FirstDocumentIdMutationOptions,
): Promise<SingleMutationResult>
Deletes a document with the given document ID. Returns a promise 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 Promise<SingleMutationResult>
Inherited from SanityClient.delete
- Defined in src/SanityClient.ts:1943
delete(
id: string,
options: AllDocumentIdsMutationOptions,
): Promise<MultipleMutationResult>
Deletes a document with the given document ID. Returns a promise 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 Promise<MultipleMutationResult>
Inherited from SanityClient.delete
- Defined in src/SanityClient.ts:1951
delete(
id: string,
options?: BaseMutationOptions,
): Promise<MultipleMutationResult>
Deletes a document with the given document ID. Returns a promise 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 Promise<MultipleMutationResult>
Inherited from SanityClient.delete
- Defined in src/SanityClient.ts:1959
delete<R extends Record<string, any> = Record<string, any>>(
selection: MutationSelection,
options: FirstDocumentMutationOptions,
): Promise<SanityDocument<R>>
Deletes one or more documents matching the given query or document ID. Returns a promise 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 Promise<SanityDocument<R>>
Inherited from SanityClient.delete
- Defined in src/SanityClient.ts:1967
delete<R extends Record<string, any> = Record<string, any>>(
selection: MutationSelection,
options: AllDocumentsMutationOptions,
): Promise<SanityDocument<R>[]>
Deletes one or more documents matching the given query or document ID. Returns a promise 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 Promise<SanityDocument<R>[]>
Inherited from SanityClient.delete
- Defined in src/SanityClient.ts:1978
delete(
selection: MutationSelection,
options: FirstDocumentIdMutationOptions,
): Promise<SingleMutationResult>
Deletes one or more documents matching the given query or document ID. Returns a promise 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 Promise<SingleMutationResult>
Inherited from SanityClient.delete
- Defined in src/SanityClient.ts:1989
delete(
selection: MutationSelection,
options: AllDocumentIdsMutationOptions,
): Promise<MultipleMutationResult>
Deletes one or more documents matching the given query or document ID. Returns a promise 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 Promise<MultipleMutationResult>
Inherited from SanityClient.delete
- Defined in src/SanityClient.ts:2000
delete(
selection: MutationSelection,
options?: BaseMutationOptions,
): Promise<MultipleMutationResult>
Deletes one or more documents matching the given query or document ID. Returns a promise 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 Promise<MultipleMutationResult>
Inherited from SanityClient.delete
- Defined in src/SanityClient.ts:2011

mutate

mutate<R extends Record<string, any> = Record<string, any>>(
operations: Mutation<R>[] | Patch | Transaction,
options: FirstDocumentMutationOptions,
): Promise<SanityDocument<R>>
Perform mutation operations against the configured dataset Returns a promise that resolves to the first mutated document.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- operations: Mutation<R>[] | Patch | Transaction
  Mutation operations to execute
- options: FirstDocumentMutationOptions
  Mutation options
Returns Promise<SanityDocument<R>>
Inherited from SanityClient.mutate
- Defined in src/SanityClient.ts:2216
mutate<R extends Record<string, any> = Record<string, any>>(
operations: Patch | Transaction | Mutation<R>[],
options: AllDocumentsMutationOptions,
): Promise<SanityDocument<R>[]>
Perform mutation operations against the configured dataset. Returns a promise that resolves to an array of the mutated documents.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- operations: Patch | Transaction | Mutation<R>[]
  Mutation operations to execute
- options: AllDocumentsMutationOptions
  Mutation options
Returns Promise<SanityDocument<R>[]>
Inherited from SanityClient.mutate
- Defined in src/SanityClient.ts:2227
mutate<R extends Record<string, any> = Record<string, any>>(
operations: Patch | Transaction | Mutation<R>[],
options: FirstDocumentIdMutationOptions,
): Promise<SingleMutationResult>
Perform mutation operations against the configured dataset Returns a promise 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: Patch | Transaction | Mutation<R>[]
  Mutation operations to execute
- options: FirstDocumentIdMutationOptions
  Mutation options
Returns Promise<SingleMutationResult>
Inherited from SanityClient.mutate
- Defined in src/SanityClient.ts:2238
mutate<R extends Record<string, any> = Record<string, any>>(
operations: Patch | Transaction | Mutation<R>[],
options: AllDocumentIdsMutationOptions,
): Promise<MultipleMutationResult>
Perform mutation operations against the configured dataset Returns a promise that resolves to a mutation result object containing the mutated document IDs.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- operations: Patch | Transaction | Mutation<R>[]
  Mutation operations to execute
- options: AllDocumentIdsMutationOptions
  Mutation options
Returns Promise<MultipleMutationResult>
Inherited from SanityClient.mutate
- Defined in src/SanityClient.ts:2249
mutate<R extends Record<string, any> = Record<string, any>>(
operations: Patch | Transaction | Mutation<R>[],
options?: BaseMutationOptions,
): Promise<MultipleMutationResult>
Perform mutation operations against the configured dataset Returns a promise that resolves to a mutation result object containing the mutated document IDs.
Type Parameters
- R extends Record<string, any> = Record<string, any>
Parameters
- operations: Patch | Transaction | Mutation<R>[]
  Mutation operations to execute
- Optionaloptions: BaseMutationOptions
  Mutation options
Returns Promise<MultipleMutationResult>
Inherited from SanityClient.mutate
- Defined in src/SanityClient.ts:2260

patch

patch(documentId: string, operations?: PatchOperations): Patch
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 Patch
Patch instance - call .commit() to perform the operations defined
Inherited from SanityClient.patch
- Defined in src/SanityClient.ts:2287
patch(documentIds: string[], operations?: PatchOperations): Patch
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 Patch
Patch instance - call .commit() to perform the operations defined
Inherited from SanityClient.patch
- Defined in src/SanityClient.ts:2296
patch(selection: MutationSelection, operations?: PatchOperations): Patch
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 Patch
Patch instance - call .commit() to perform the operations defined
Inherited from SanityClient.patch
- Defined in src/SanityClient.ts:2305

transaction

transaction<R extends Record<string, any> = Record<string, any>>(
operations?: Mutation<R>[],
): Transaction
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 Transaction
Inherited from SanityClient.transaction
- Defined in src/SanityClient.ts:2325

Methods - Versions

createVersion

createVersion<R extends Record<string, any>>(
    args: {
        document: SanityDocumentStub<R>;
        publishedId: string;
        releaseId?: string;
    },
    options?: BaseActionOptions,
): Promise<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 Promise<SingleActionResult | MultipleActionResult>
A promise that resolves to the transactionId.
Remarks
- The preferred approach is to use baseId to refer to the existing published document, but it is also possible to provide a complete document instead.
- If document is provided, it must have 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
```
const transactionId = await client.createVersion({
  baseId: 'myDocument',
  publishedId: 'myDocument',
  releaseId: 'myRelease',
})

// 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
```
const transactionId = await client.createVersion({
  baseId: 'myDocument',
  publishedId: 'myDocument',
})

// The following document will be created:
// {
//   _id: 'drafts.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Inherited from SanityClient.createVersion
- Defined in src/SanityClient.ts:1841
createVersion<R extends Record<string, any>>(
    args: {
        document: IdentifiedSanityDocumentStub<R>;
        publishedId?: string;
        releaseId?: string;
    },
    options?: BaseActionOptions,
): Promise<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 Promise<SingleActionResult | MultipleActionResult>
A promise that resolves to the transactionId.
Remarks
- The preferred approach is to use baseId to refer to the existing published document, but it is also possible to provide a complete document instead.
- If document is provided, it must have 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
```
const transactionId = await client.createVersion({
  baseId: 'myDocument',
  publishedId: 'myDocument',
  releaseId: 'myRelease',
})

// 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
```
const transactionId = await client.createVersion({
  baseId: 'myDocument',
  publishedId: 'myDocument',
})

// The following document will be created:
// {
//   _id: 'drafts.myDocument',
//   _type: 'myDocument',
//   title: 'My Document',
// }
```
Inherited from SanityClient.createVersion
- Defined in src/SanityClient.ts:1849
createVersion(
    args: {
        baseId: string;
        ifBaseRevisionId?: string;
        publishedId: string;
        releaseId?: string;
    },
    options?: BaseActionOptions,
): Promise<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 Promise<SingleActionResult | MultipleActionResult>
A promise that resolves to the transactionId.
Remarks
- The preferred approach is to use baseId to refer to the existing published document, but it is also possible to provide a complete document instead.
- If document is provided, it must have 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
```
const transactionId = await client.createVersion({
  baseId: 'myDocument',
  publishedId: 'myDocument',
  releaseId: 'myRelease',
})

// 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
```
const transactionId = await client.createVersion({
  baseId: 'myDocument',
  publishedId: 'myDocument',
})

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

discardVersion

discardVersion(
    params: { publishedId: string; releaseId?: string },
    purge?: boolean,
    options?: BaseActionOptions,
): Promise<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 Promise<SingleActionResult | MultipleActionResult>
a promise 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.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.discardVersion({publishedId: 'myDocument'})
// The document with the ID `drafts.myDocument` will be discarded.
```
Inherited from SanityClient.discardVersion
- Defined in src/SanityClient.ts:2059

replaceVersion

replaceVersion<R extends Record<string, any>>(
    args: {
        document: SanityDocumentStub<R>;
        publishedId: string;
        releaseId?: string;
    },
    options?: BaseActionOptions,
): Promise<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 Promise<SingleActionResult | MultipleActionResult>
a promise 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
```
await client.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
```
await client.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
```
await client.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 SanityClient.replaceVersion
- Defined in src/SanityClient.ts:2136
replaceVersion<R extends Record<string, any>>(
    args: {
        document: IdentifiedSanityDocumentStub<R>;
        publishedId?: string;
        releaseId?: string;
    },
    options?: BaseActionOptions,
): Promise<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 Promise<SingleActionResult | MultipleActionResult>
a promise 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
```
await client.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
```
await client.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
```
await client.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 SanityClient.replaceVersion
- Defined in src/SanityClient.ts:2144

unpublishVersion

unpublishVersion(
params: { publishedId: string; releaseId: string },
options?: BaseActionOptions,
): Promise<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 Promise<SingleActionResult | MultipleActionResult>
a promise 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
```
await client.unpublishVersion({publishedId: 'myDocument', releaseId: 'myRelease'})
// The document with the ID `versions.myRelease.myDocument` will be unpublished. when `myRelease` is run.
```
Inherited from SanityClient.unpublishVersion
- Defined in src/SanityClient.ts:2198

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 SanityClient.getDataUrl
- Defined in src/SanityClient.ts:2394

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 SanityClient.getUrl
- Defined in src/SanityClient.ts:2382

request

request<R = any>(options: RawRequestOptions): Promise<R>
Perform a request against the Sanity API NOTE: Only use this for Sanity API endpoints, not for your own APIs!
Type Parameters
- R = any
Parameters
- options: RawRequestOptions
  Request options
Returns Promise<R>
Promise resolving to the response body
Inherited from SanityClient.request
- Defined in src/SanityClient.ts:2356

Class SanityStegaClient

Deprecated

Hierarchy (View Summary)

Index

Constructors

Properties - Configuration

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 SanityStegaClient

Properties - Configuration

observable

Properties - Releases

releases

Type declaration

archive: function

Parameters

Returns Promise<SingleActionResult>

create: function

Parameters

Returns Promise< 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 with a custom transaction id

Parameters

Returns Promise< 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 with a custom transaction id

delete: function

Parameters

Returns Promise<SingleActionResult>

edit: function

Parameters

Returns Promise<SingleActionResult>

fetchDocuments: function

Parameters

Returns Promise<RawQueryResponse<SanityDocument[]>>

get: function

Parameters

Returns Promise<ReleaseDocument | undefined>

Example: Retrieving a release by id

publish: function

Parameters

Returns Promise<SingleActionResult>

schedule: function

Parameters

Returns Promise<SingleActionResult>

unarchive: function

Parameters

Returns Promise<SingleActionResult>

unschedule: function

Parameters

Returns Promise<SingleActionResult>

Properties - Assets

assets

Type declaration

upload: function

Parameters

Returns Promise<SanityAssetDocument>

Parameters

Returns Promise<SanityImageAssetDocument>

Parameters

Returns Promise<SanityAssetDocument | SanityImageAssetDocument>

mediaLibrary

Type declaration

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

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

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

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

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

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

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

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

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

`Optional`includeDrafts?: boolean

`Optional`tag?: string

`Optional`waitFor?: "function"