@dfinity/assets/lib/cjs/canisters/assets_service.d.ts

JavaScript and TypeScript library to manage assets on the Internet Computer

import type { Principal } from '@dfinity/principal';
export declare type BatchId = bigint;
export declare type BatchOperationKind = {
    CreateAsset: CreateAssetArguments;
} | {
    UnsetAssetContent: UnsetAssetContentArguments;
} | {
    DeleteAsset: DeleteAssetArguments;
} | {
    SetAssetContent: SetAssetContentArguments;
} | {
    Clear: ClearArguments;
};
export declare type ChunkId = bigint;
export declare type ClearArguments = Record<string, never>;
export interface CreateAssetArguments {
    key: Key;
    content_type: string;
    headers: [] | [Array<HeaderField>];
}
export interface DeleteAssetArguments {
    key: Key;
}
export declare type HeaderField = [string, string];
export interface HttpRequest {
    url: string;
    method: string;
    body: Uint8Array;
    headers: Array<HeaderField>;
}
export interface HttpResponse {
    body: Uint8Array;
    headers: Array<HeaderField>;
    streaming_strategy: [] | [StreamingStrategy];
    status_code: number;
}
export declare type Key = string;
export declare type Result = {
    Ok: null;
} | {
    Err: string;
};
export interface SetAssetContentArguments {
    key: Key;
    sha256: [] | [Uint8Array];
    chunk_ids: Array<ChunkId>;
    content_encoding: string;
}
export interface StreamingCallbackHttpResponse {
    token: [] | [StreamingCallbackToken];
    body: Uint8Array;
}
export interface StreamingCallbackToken {
    key: Key;
    sha256: [] | [Uint8Array];
    index: bigint;
    content_encoding: string;
}
export declare type StreamingStrategy = {
    Callback: {
        token: StreamingCallbackToken;
        callback: [Principal, string];
    };
};
export declare type Time = bigint;
export interface UnsetAssetContentArguments {
    key: Key;
    content_encoding: string;
}
export default interface _SERVICE {
    authorize: (arg_0: Principal) => Promise<undefined>;
    clear: (arg_0: ClearArguments) => Promise<undefined>;
    commit_batch: (arg_0: {
        batch_id: BatchId;
        operations: Array<BatchOperationKind>;
    }) => Promise<undefined>;
    create_asset: (arg_0: CreateAssetArguments) => Promise<undefined>;
    create_batch: (arg_0: Record<string, never>) => Promise<{
        batch_id: BatchId;
    }>;
    create_chunk: (arg_0: {
        content: Uint8Array;
        batch_id: BatchId;
    }) => Promise<{
        chunk_id: ChunkId;
    }>;
    delete_asset: (arg_0: DeleteAssetArguments) => Promise<undefined>;
    get: (arg_0: {
        key: Key;
        accept_encodings: Array<string>;
    }) => Promise<{
        content: Uint8Array;
        sha256: [] | [Uint8Array];
        content_type: string;
        content_encoding: string;
        total_length: bigint;
    }>;
    get_chunk: (arg_0: {
        key: Key;
        sha256: [] | [Uint8Array];
        index: bigint;
        content_encoding: string;
    }) => Promise<{
        content: Uint8Array;
    }>;
    http_request: (arg_0: HttpRequest) => Promise<HttpResponse>;
    http_request_streaming_callback: (arg_0: StreamingCallbackToken) => Promise<[] | [StreamingCallbackHttpResponse]>;
    list: (arg_0: Record<string, never>) => Promise<Array<{
        key: Key;
        encodings: Array<{
            modified: Time;
            sha256: [] | [Uint8Array];
            length: bigint;
            content_encoding: string;
        }>;
        content_type: string;
    }>>;
    set_asset_content: (arg_0: SetAssetContentArguments) => Promise<undefined>;
    store: (arg_0: {
        key: Key;
        content: Uint8Array;
        sha256: [] | [Uint8Array];
        content_type: string;
        content_encoding: string;
    }) => Promise<undefined>;
    unset_asset_content: (arg_0: UnsetAssetContentArguments) => Promise<undefined>;
}