@azure-rest/confidential-ledger 1.0.0-beta.2 → 1.0.0

package/types/confidential-ledger.d.ts

@@ -1,102 +1,152 @@
-import { CertificateCredential } from '@azure-rest/core-client';
 import { Client } from '@azure-rest/core-client';
 import { ClientOptions } from '@azure-rest/core-client';
 import { HttpResponse } from '@azure-rest/core-client';
+import { PagedAsyncIterableIterator } from '@azure/core-paging';
+import { PathUncheckedResponse } from '@azure-rest/core-client';
 import { RawHttpHeaders } from '@azure/core-rest-pipeline';
 import { RequestParameters } from '@azure-rest/core-client';
+import { StreamableMethod } from '@azure-rest/core-client';
 import { TokenCredential } from '@azure/core-auth';
 
-declare function ConfidentialLedger(ledgerBaseUrl: string, ledgerTlsCertificate: string, credentials: TokenCredential | CertificateCredential, options?: ClientOptions): ConfidentialLedgerRestClient;
+export declare interface CollectionOutput {
+    collectionId: string;
+}
+
+declare function ConfidentialLedger(ledgerEndpoint: string, ledgerIdentityCertificate: string, options?: ClientOptions): ConfidentialLedgerClient;
+
+declare function ConfidentialLedger(ledgerEndpoint: string, ledgerIdentityCertificate: string, credentials: TokenCredential, options?: ClientOptions): ConfidentialLedgerClient;
 export default ConfidentialLedger;
 
-export declare interface ConfidentialLedgerEnclaves {
+export declare type ConfidentialLedgerClient = Client & {
+    path: Routes;
+};
+
+export declare interface ConfidentialLedgerEnclavesOutput {
     /** Id of the Confidential Ledger node responding to the request. */
     currentNodeId: string;
     /** Dictionary of enclave quotes, indexed by node id. */
-    enclaveQuotes: EnclaveQuotesDictionary;
-}
-
-export declare interface ConfidentialLedgerError {
-    /** An error response from Confidential Ledger. */
-    error?: ConfidentialLedgerErrorBody;
+    enclaveQuotes: Record<string, EnclaveQuoteOutput>;
 }
 
-export declare interface ConfidentialLedgerErrorBody {
+export declare interface ConfidentialLedgerErrorBodyOutput {
     /** The error code. */
     code?: string;
     /** The error message. */
     message?: string;
-    /** An error response from Confidential Ledger. */
-    innerError?: ConfidentialLedgerErrorBody;
 }
 
-export declare type ConfidentialLedgerQueryState = "Loading" | "Ready";
-
-export declare type ConfidentialLedgerRestClient = Client & {
-    path: Routes;
-};
-
-export declare type ConfidentialLedgerUserRoleName = "Administrator" | "Contributor" | "Reader";
-
-export declare interface Consortium {
-    members: ConsortiumMember[];
+export declare interface ConfidentialLedgerErrorOutput {
+    /** An error response from Confidential Ledger. */
+    error?: ConfidentialLedgerErrorBodyOutput;
 }
 
-export declare interface ConsortiumMember {
+export declare interface ConsortiumMemberOutput {
     /** PEM-encoded certificate associated with the member. */
     certificate: string;
     /** Identifier assigned to the member. */
     id: string;
 }
 
-export declare interface Constitution {
+export declare interface ConsortiumOutput {
+    members: Array<ConsortiumMemberOutput>;
+    /** Path from which to retrieve the next page of results. */
+    nextLink?: string;
+}
+
+export declare interface ConstitutionOutput {
     /** SHA256 digest of the constitution script. */
     digest: string;
     /** Contents of the constitution. */
     script: string;
 }
 
-export declare interface CreateOrUpdateUser {
-    /** Deletes a user from the Confidential Ledger. */
-    delete(options?: DeleteUserParameters): Promise<DeleteUser204Response | DeleteUserdefaultResponse>;
-    /** Gets a user. */
-    get(options?: GetUserParameters): Promise<GetUser200Response | GetUserdefaultResponse>;
-    /** A JSON merge patch is applied for existing users */
-    patch(options: CreateOrUpdateUserParameters): Promise<CreateOrUpdateUser200Response | CreateOrUpdateUserdefaultResponse>;
+export declare interface CreateLedgerEntry200Headers {
+    /** The transaction id at which this write will become durable. */
+    "x-ms-ccf-transaction-id"?: string;
+}
+
+/** A collection id may optionally be specified. */
+export declare interface CreateLedgerEntry200Response extends HttpResponse {
+    status: "200";
+    body: LedgerWriteResultOutput;
+    headers: RawHttpHeaders & CreateLedgerEntry200Headers;
+}
+
+export declare interface CreateLedgerEntryBodyParam {
+    /** Ledger entry. */
+    body: LedgerEntry;
+}
+
+/** A collection id may optionally be specified. */
+export declare interface CreateLedgerEntrydefaultResponse extends HttpResponse {
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
+}
+
+export declare interface CreateLedgerEntryMediaTypesParam {
+    /** Request content type */
+    contentType?: "application/json";
+}
+
+export declare type CreateLedgerEntryParameters = CreateLedgerEntryQueryParam & CreateLedgerEntryMediaTypesParam & CreateLedgerEntryBodyParam & RequestParameters;
+
+export declare interface CreateLedgerEntryQueryParam {
+    queryParameters?: CreateLedgerEntryQueryParamProperties;
+}
+
+export declare interface CreateLedgerEntryQueryParamProperties {
+    /** The collection id. */
+    collectionId?: string;
 }
 
 /** A JSON merge patch is applied for existing users */
 export declare interface CreateOrUpdateUser200Response extends HttpResponse {
     status: "200";
-    body: LedgerUser;
+    body: LedgerUserOutput;
 }
 
 export declare interface CreateOrUpdateUserBodyParam {
+    /** Details about a Confidential Ledger user. */
     body: LedgerUser;
 }
 
 /** A JSON merge patch is applied for existing users */
 export declare interface CreateOrUpdateUserdefaultResponse extends HttpResponse {
-    status: "500";
-    body: ConfidentialLedgerError;
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
+}
+
+export declare interface CreateOrUpdateUserMediaTypesParam {
+    /** Request content type */
+    contentType?: "application/merge-patch+json";
 }
 
-export declare type CreateOrUpdateUserParameters = RequestParameters & CreateOrUpdateUserBodyParam;
+export declare type CreateOrUpdateUserParameters = CreateOrUpdateUserMediaTypesParam & CreateOrUpdateUserBodyParam & RequestParameters;
+
+export declare interface DeleteUser {
+    /** Deletes a user from the Confidential Ledger. */
+    delete(options?: DeleteUserParameters): StreamableMethod<DeleteUser204Response | DeleteUserdefaultResponse>;
+    /** Gets a user. */
+    get(options?: GetUserParameters): StreamableMethod<GetUser200Response | GetUserdefaultResponse>;
+    /** A JSON merge patch is applied for existing users */
+    patch(options: CreateOrUpdateUserParameters): StreamableMethod<CreateOrUpdateUser200Response | CreateOrUpdateUserdefaultResponse>;
+}
 
 /** Deletes a user from the Confidential Ledger. */
 export declare interface DeleteUser204Response extends HttpResponse {
     status: "204";
+    body: Record<string, unknown>;
 }
 
 /** Deletes a user from the Confidential Ledger. */
 export declare interface DeleteUserdefaultResponse extends HttpResponse {
-    status: "500";
-    body: ConfidentialLedgerError;
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
 }
 
 export declare type DeleteUserParameters = RequestParameters;
 
-export declare interface EnclaveQuote {
+export declare interface EnclaveQuoteOutput {
     /** ID assigned to this node. */
     nodeId: string;
     /** MRENCLAVE value of the code running in the enclave. */
@@ -107,184 +157,149 @@ export declare interface EnclaveQuote {
     raw: string;
 }
 
-export declare type EnclaveQuotesDictionary = Record<string, EnclaveQuote>;
-
-export declare interface GetConsortiumMembers {
-    /** Consortium members can manage the Confidential Ledger. */
-    get(options?: GetConsortiumMembersParameters): Promise<GetConsortiumMembers200Response | GetConsortiumMembersdefaultResponse>;
-}
-
-/** Consortium members can manage the Confidential Ledger. */
-export declare interface GetConsortiumMembers200Response extends HttpResponse {
-    status: "200";
-    body: Consortium;
-}
-
-/** Consortium members can manage the Confidential Ledger. */
-export declare interface GetConsortiumMembersdefaultResponse extends HttpResponse {
-    status: "500";
-    body: ConfidentialLedgerError;
-}
-
-export declare type GetConsortiumMembersParameters = RequestParameters;
+/**
+ * Helper type to extract the type of an array
+ */
+export declare type GetArrayType<T> = T extends Array<infer TData> ? TData : never;
 
 export declare interface GetConstitution {
     /** The constitution is a script that assesses and applies proposals from consortium members. */
-    get(options?: GetConstitutionParameters): Promise<GetConstitution200Response | GetConstitutiondefaultResponse>;
+    get(options?: GetConstitutionParameters): StreamableMethod<GetConstitution200Response | GetConstitutiondefaultResponse>;
 }
 
 /** The constitution is a script that assesses and applies proposals from consortium members. */
 export declare interface GetConstitution200Response extends HttpResponse {
     status: "200";
-    body: Constitution;
+    body: ConstitutionOutput;
 }
 
 /** The constitution is a script that assesses and applies proposals from consortium members. */
 export declare interface GetConstitutiondefaultResponse extends HttpResponse {
-    status: "500";
-    body: ConfidentialLedgerError;
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
 }
 
 export declare type GetConstitutionParameters = RequestParameters;
 
 export declare interface GetCurrentLedgerEntry {
-    /** A sub-ledger id may optionally be specified. */
-    get(options?: GetCurrentLedgerEntryParameters): Promise<GetCurrentLedgerEntry200Response | GetCurrentLedgerEntrydefaultResponse>;
+    /** A collection id may optionally be specified. */
+    get(options?: GetCurrentLedgerEntryParameters): StreamableMethod<GetCurrentLedgerEntry200Response | GetCurrentLedgerEntrydefaultResponse>;
 }
 
-/** A sub-ledger id may optionally be specified. */
+/** A collection id may optionally be specified. */
 export declare interface GetCurrentLedgerEntry200Response extends HttpResponse {
     status: "200";
-    body: LedgerEntry;
+    body: LedgerEntryOutput;
 }
 
-/** A sub-ledger id may optionally be specified. */
+/** A collection id may optionally be specified. */
 export declare interface GetCurrentLedgerEntrydefaultResponse extends HttpResponse {
-    status: "500";
-    body: ConfidentialLedgerError;
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
 }
 
-export declare type GetCurrentLedgerEntryParameters = RequestParameters & GetCurrentLedgerEntryQueryParam;
+export declare type GetCurrentLedgerEntryParameters = GetCurrentLedgerEntryQueryParam & RequestParameters;
 
 export declare interface GetCurrentLedgerEntryQueryParam {
     queryParameters?: GetCurrentLedgerEntryQueryParamProperties;
 }
 
 export declare interface GetCurrentLedgerEntryQueryParamProperties {
-    /** The sub-ledger id. */
-    subLedgerId?: string;
+    /** The collection id. */
+    collectionId?: string;
 }
 
 export declare interface GetEnclaveQuotes {
     /** A quote is an SGX enclave measurement that can be used to verify the validity of a node and its enclave. */
-    get(options?: GetEnclaveQuotesParameters): Promise<GetEnclaveQuotes200Response | GetEnclaveQuotesdefaultResponse>;
+    get(options?: GetEnclaveQuotesParameters): StreamableMethod<GetEnclaveQuotes200Response | GetEnclaveQuotesdefaultResponse>;
 }
 
 /** A quote is an SGX enclave measurement that can be used to verify the validity of a node and its enclave. */
 export declare interface GetEnclaveQuotes200Response extends HttpResponse {
     status: "200";
-    body: ConfidentialLedgerEnclaves;
+    body: ConfidentialLedgerEnclavesOutput;
 }
 
 /** A quote is an SGX enclave measurement that can be used to verify the validity of a node and its enclave. */
 export declare interface GetEnclaveQuotesdefaultResponse extends HttpResponse {
-    status: "500";
-    body: ConfidentialLedgerError;
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
 }
 
 export declare type GetEnclaveQuotesParameters = RequestParameters;
 
-/** A sub-ledger id may optionally be specified. Only entries in the specified (or default) sub-ledger will be returned. */
-export declare interface GetLedgerEntries200Response extends HttpResponse {
-    status: "200";
-    body: PagedLedgerEntries;
-}
-
-/** A sub-ledger id may optionally be specified. Only entries in the specified (or default) sub-ledger will be returned. */
-export declare interface GetLedgerEntriesdefaultResponse extends HttpResponse {
-    status: "500";
-    body: ConfidentialLedgerError;
-}
-
-export declare type GetLedgerEntriesParameters = RequestParameters & GetLedgerEntriesQueryParam;
-
-export declare interface GetLedgerEntriesQueryParam {
-    queryParameters?: GetLedgerEntriesQueryParamProperties;
-}
-
-export declare interface GetLedgerEntriesQueryParamProperties {
-    /** The sub-ledger id. */
-    subLedgerId?: string;
-    /** Specify the first transaction ID in a range. */
-    fromTransactionId?: string;
-    /** Specify the last transaction ID in a range. */
-    toTransactionId?: string;
-}
-
 export declare interface GetLedgerEntry {
     /** To return older ledger entries, the relevant sections of the ledger must be read from disk and validated. To prevent blocking within the enclave, the response will indicate whether the entry is ready and part of the response, or if the loading is still ongoing. */
-    get(options?: GetLedgerEntryParameters): Promise<GetLedgerEntry200Response | GetLedgerEntrydefaultResponse>;
+    get(options?: GetLedgerEntryParameters): StreamableMethod<GetLedgerEntry200Response | GetLedgerEntrydefaultResponse>;
 }
 
 /** To return older ledger entries, the relevant sections of the ledger must be read from disk and validated. To prevent blocking within the enclave, the response will indicate whether the entry is ready and part of the response, or if the loading is still ongoing. */
 export declare interface GetLedgerEntry200Response extends HttpResponse {
     status: "200";
-    body: LedgerQueryResult;
+    body: LedgerQueryResultOutput;
 }
 
 /** To return older ledger entries, the relevant sections of the ledger must be read from disk and validated. To prevent blocking within the enclave, the response will indicate whether the entry is ready and part of the response, or if the loading is still ongoing. */
 export declare interface GetLedgerEntrydefaultResponse extends HttpResponse {
-    status: "500";
-    body: ConfidentialLedgerError;
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
 }
 
-export declare type GetLedgerEntryParameters = RequestParameters & GetLedgerEntryQueryParam;
+export declare type GetLedgerEntryParameters = GetLedgerEntryQueryParam & RequestParameters;
 
 export declare interface GetLedgerEntryQueryParam {
     queryParameters?: GetLedgerEntryQueryParamProperties;
 }
 
 export declare interface GetLedgerEntryQueryParamProperties {
-    /** The sub-ledger id. */
-    subLedgerId?: string;
+    /** The collection id. */
+    collectionId?: string;
 }
 
 export declare function getLedgerIdentity(ledgerId: string, identityServiceBaseUrl?: string): Promise<LedgerIdentity>;
 
+/**
+ * The type of a custom function that defines how to get a page and a link to the next one if any.
+ */
+export declare type GetPage<TPage> = (pageLink: string, maxPageSize?: number) => Promise<{
+    page: TPage;
+    nextPageLink?: string;
+}>;
+
 export declare interface GetReceipt {
     /** Gets a receipt certifying ledger contents at a particular transaction id. */
-    get(options?: GetReceiptParameters): Promise<GetReceipt200Response | GetReceiptdefaultResponse>;
+    get(options?: GetReceiptParameters): StreamableMethod<GetReceipt200Response | GetReceiptdefaultResponse>;
 }
 
 /** Gets a receipt certifying ledger contents at a particular transaction id. */
 export declare interface GetReceipt200Response extends HttpResponse {
     status: "200";
-    body: TransactionReceipt;
+    body: TransactionReceiptOutput;
 }
 
 /** Gets a receipt certifying ledger contents at a particular transaction id. */
 export declare interface GetReceiptdefaultResponse extends HttpResponse {
-    status: "500";
-    body: ConfidentialLedgerError;
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
 }
 
 export declare type GetReceiptParameters = RequestParameters;
 
 export declare interface GetTransactionStatus {
     /** Gets the status of an entry identified by a transaction id. */
-    get(options?: GetTransactionStatusParameters): Promise<GetTransactionStatus200Response | GetTransactionStatusdefaultResponse>;
+    get(options?: GetTransactionStatusParameters): StreamableMethod<GetTransactionStatus200Response | GetTransactionStatusdefaultResponse>;
 }
 
 /** Gets the status of an entry identified by a transaction id. */
 export declare interface GetTransactionStatus200Response extends HttpResponse {
     status: "200";
-    body: TransactionStatus;
+    body: TransactionStatusOutput;
 }
 
 /** Gets the status of an entry identified by a transaction id. */
 export declare interface GetTransactionStatusdefaultResponse extends HttpResponse {
-    status: "500";
-    body: ConfidentialLedgerError;
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
 }
 
 export declare type GetTransactionStatusParameters = RequestParameters;
@@ -292,133 +307,253 @@ export declare type GetTransactionStatusParameters = RequestParameters;
 /** Gets a user. */
 export declare interface GetUser200Response extends HttpResponse {
     status: "200";
-    body: LedgerUser;
+    body: LedgerUserOutput;
 }
 
 /** Gets a user. */
 export declare interface GetUserdefaultResponse extends HttpResponse {
-    status: "500";
-    body: ConfidentialLedgerError;
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
 }
 
 export declare type GetUserParameters = RequestParameters;
 
+export declare function isUnexpected(response: GetConstitution200Response | GetConstitutiondefaultResponse): response is GetConstitutiondefaultResponse;
+
+export declare function isUnexpected(response: ListConsortiumMembers200Response | ListConsortiumMembersdefaultResponse): response is ListConsortiumMembersdefaultResponse;
+
+export declare function isUnexpected(response: GetEnclaveQuotes200Response | GetEnclaveQuotesdefaultResponse): response is GetEnclaveQuotesdefaultResponse;
+
+export declare function isUnexpected(response: ListCollections200Response | ListCollectionsdefaultResponse): response is ListCollectionsdefaultResponse;
+
+export declare function isUnexpected(response: ListLedgerEntries200Response | ListLedgerEntriesdefaultResponse): response is ListLedgerEntriesdefaultResponse;
+
+export declare function isUnexpected(response: CreateLedgerEntry200Response | CreateLedgerEntrydefaultResponse): response is CreateLedgerEntrydefaultResponse;
+
+export declare function isUnexpected(response: GetLedgerEntry200Response | GetLedgerEntrydefaultResponse): response is GetLedgerEntrydefaultResponse;
+
+export declare function isUnexpected(response: GetReceipt200Response | GetReceiptdefaultResponse): response is GetReceiptdefaultResponse;
+
+export declare function isUnexpected(response: GetTransactionStatus200Response | GetTransactionStatusdefaultResponse): response is GetTransactionStatusdefaultResponse;
+
+export declare function isUnexpected(response: GetCurrentLedgerEntry200Response | GetCurrentLedgerEntrydefaultResponse): response is GetCurrentLedgerEntrydefaultResponse;
+
+export declare function isUnexpected(response: DeleteUser204Response | DeleteUserdefaultResponse): response is DeleteUserdefaultResponse;
+
+export declare function isUnexpected(response: GetUser200Response | GetUserdefaultResponse): response is GetUserdefaultResponse;
+
+export declare function isUnexpected(response: CreateOrUpdateUser200Response | CreateOrUpdateUserdefaultResponse): response is CreateOrUpdateUserdefaultResponse;
+
 export declare interface LedgerEntry {
     /** Contents of the ledger entry. */
     contents: string;
-    /** Identifier for sub-ledgers. */
-    subLedgerId?: string;
+    collectionId?: string;
+    /** A unique identifier for the state of the ledger. If returned as part of a LedgerEntry, it indicates the state from which the entry was read. */
+    transactionId?: string;
+}
+
+export declare interface LedgerEntryOutput {
+    /** Contents of the ledger entry. */
+    contents: string;
+    collectionId?: string;
     /** A unique identifier for the state of the ledger. If returned as part of a LedgerEntry, it indicates the state from which the entry was read. */
     transactionId?: string;
 }
 
 export declare interface LedgerIdentity {
-    ledgerTlsCertificate: string;
+    ledgerIdentityCertificate: string;
     ledgerId: string;
 }
 
-export declare interface LedgerQueryResult {
+export declare interface LedgerQueryResultOutput {
     /** State of a ledger query. */
-    state: ConfidentialLedgerQueryState;
+    state: "Loading" | "Ready";
     /** The ledger entry found as a result of the query. This is only available if the query is in Ready state. */
-    entry?: LedgerEntry;
+    entry?: LedgerEntryOutput;
 }
 
 export declare interface LedgerUser {
     /** Represents an assignable role. */
-    assignedRole: ConfidentialLedgerUserRoleName;
+    assignedRole: "Administrator" | "Contributor" | "Reader";
     /** Identifier for the user. This must either be an AAD object id or a certificate fingerprint. */
     userId?: string;
 }
 
-export declare interface LedgerWriteResult {
-    /** Identifier for sub-ledgers. */
-    subLedgerId: string;
+export declare interface LedgerUserOutput {
+    /** Represents an assignable role. */
+    assignedRole: "Administrator" | "Contributor" | "Reader";
+    /** Identifier for the user. This must either be an AAD object id or a certificate fingerprint. */
+    userId?: string;
 }
 
-export declare interface MerkleProofElement {
-    left?: string;
-    right?: string;
+export declare interface LedgerWriteResultOutput {
+    collectionId: string;
 }
 
-export declare interface PagedLedgerEntries {
-    /** State of a ledger query. */
-    state: ConfidentialLedgerQueryState;
-    /** Path from which to retrieve the next page of results. */
-    nextLink?: string;
-    /** Array of ledger entries. */
-    entries: LedgerEntry[];
+export declare interface ListCollections {
+    /** Collection ids are user-created collections of ledger entries */
+    get(options?: ListCollectionsParameters): StreamableMethod<ListCollections200Response | ListCollectionsdefaultResponse>;
 }
 
-export declare interface PostLedgerEntry {
-    /** A sub-ledger id may optionally be specified. Only entries in the specified (or default) sub-ledger will be returned. */
-    get(options?: GetLedgerEntriesParameters): Promise<GetLedgerEntries200Response | GetLedgerEntriesdefaultResponse>;
-    /** A sub-ledger id may optionally be specified. */
-    post(options?: PostLedgerEntryParameters): Promise<PostLedgerEntry200Response | PostLedgerEntrydefaultResponse>;
+/** Collection ids are user-created collections of ledger entries */
+export declare interface ListCollections200Response extends HttpResponse {
+    status: "200";
+    body: PagedCollectionsOutput;
 }
 
-export declare interface PostLedgerEntry200Headers {
-    /** The transaction id at which this write will become durable. */
-    "x-ms-ccf-transaction-id"?: string;
+/** Collection ids are user-created collections of ledger entries */
+export declare interface ListCollectionsdefaultResponse extends HttpResponse {
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
 }
 
-/** A sub-ledger id may optionally be specified. */
-export declare interface PostLedgerEntry200Response extends HttpResponse {
+export declare type ListCollectionsParameters = RequestParameters;
+
+export declare interface ListConsortiumMembers {
+    /** Consortium members can manage the Confidential Ledger. */
+    get(options?: ListConsortiumMembersParameters): StreamableMethod<ListConsortiumMembers200Response | ListConsortiumMembersdefaultResponse>;
+}
+
+/** Consortium members can manage the Confidential Ledger. */
+export declare interface ListConsortiumMembers200Response extends HttpResponse {
     status: "200";
-    body: LedgerWriteResult;
-    headers: RawHttpHeaders & PostLedgerEntry200Headers;
+    body: ConsortiumOutput;
 }
 
-export declare interface PostLedgerEntryBodyParam {
-    body?: LedgerEntry;
+/** Consortium members can manage the Confidential Ledger. */
+export declare interface ListConsortiumMembersdefaultResponse extends HttpResponse {
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
+}
+
+export declare type ListConsortiumMembersParameters = RequestParameters;
+
+export declare interface ListLedgerEntries {
+    /** A collection id may optionally be specified. Only entries in the specified (or default) collection will be returned. */
+    get(options?: ListLedgerEntriesParameters): StreamableMethod<ListLedgerEntries200Response | ListLedgerEntriesdefaultResponse>;
+    /** A collection id may optionally be specified. */
+    post(options: CreateLedgerEntryParameters): StreamableMethod<CreateLedgerEntry200Response | CreateLedgerEntrydefaultResponse>;
 }
 
-/** A sub-ledger id may optionally be specified. */
-export declare interface PostLedgerEntrydefaultResponse extends HttpResponse {
-    status: "500";
-    body: ConfidentialLedgerError;
+/** A collection id may optionally be specified. Only entries in the specified (or default) collection will be returned. */
+export declare interface ListLedgerEntries200Response extends HttpResponse {
+    status: "200";
+    body: PagedLedgerEntriesOutput;
+}
+
+/** A collection id may optionally be specified. Only entries in the specified (or default) collection will be returned. */
+export declare interface ListLedgerEntriesdefaultResponse extends HttpResponse {
+    status: string;
+    body: ConfidentialLedgerErrorOutput;
 }
 
-export declare type PostLedgerEntryParameters = RequestParameters & PostLedgerEntryQueryParam & PostLedgerEntryBodyParam;
+export declare type ListLedgerEntriesParameters = ListLedgerEntriesQueryParam & RequestParameters;
+
+export declare interface ListLedgerEntriesQueryParam {
+    queryParameters?: ListLedgerEntriesQueryParamProperties;
+}
 
-export declare interface PostLedgerEntryQueryParam {
-    queryParameters?: PostLedgerEntryQueryParamProperties;
+export declare interface ListLedgerEntriesQueryParamProperties {
+    /** The collection id. */
+    collectionId?: string;
+    /** Specify the first transaction ID in a range. */
+    fromTransactionId?: string;
+    /** Specify the last transaction ID in a range. */
+    toTransactionId?: string;
 }
 
-export declare interface PostLedgerEntryQueryParamProperties {
-    /** The sub-ledger id. */
-    subLedgerId?: string;
+export declare interface PagedCollectionsOutput {
+    collections: Array<CollectionOutput>;
+    /** Path from which to retrieve the next page of results. */
+    nextLink?: string;
 }
 
-export declare interface ReceiptContents {
-    /** Merkle tree leaf for this transaction. */
-    leaf: string;
-    /** Id of the node returning the receipt. */
+export declare interface PagedLedgerEntriesOutput {
+    /** State of a ledger query. */
+    state: "Loading" | "Ready";
+    /** Path from which to retrieve the next page of results. */
+    nextLink?: string;
+    /** Array of ledger entries. */
+    entries: Array<LedgerEntryOutput>;
+}
+
+/**
+ * Helper to paginate results from an initial response that follows the specification of Autorest `x-ms-pageable` extension
+ * @param client - Client to use for sending the next page requests
+ * @param initialResponse - Initial response containing the nextLink and current page of elements
+ * @param customGetPage - Optional - Function to define how to extract the page and next link to be used to paginate the results
+ * @returns - PagedAsyncIterableIterator to iterate the elements
+ */
+export declare function paginate<TResponse extends PathUncheckedResponse>(client: Client, initialResponse: TResponse, options?: PagingOptions<TResponse>): PagedAsyncIterableIterator<PaginateReturn<TResponse>>;
+
+/**
+ * Helper type to infer the Type of the paged elements from the response type
+ * This type is generated based on the swagger information for x-ms-pageable
+ * specifically on the itemName property which indicates the property of the response
+ * where the page items are found. The default value is `value`.
+ * This type will allow us to provide strongly typed Iterator based on the response we get as second parameter
+ */
+export declare type PaginateReturn<TResult> = TResult extends {
+    body: {
+        value?: infer TPage;
+    };
+} | {
+    body: {
+        members?: infer TPage;
+    };
+} | {
+    body: {
+        collections?: infer TPage;
+    };
+} | {
+    body: {
+        entries?: infer TPage;
+    };
+} ? GetArrayType<TPage> : Array<unknown>;
+
+/**
+ * Options for the paging helper
+ */
+export declare interface PagingOptions<TResponse> {
+    /**
+     * Custom function to extract pagination details for crating the PagedAsyncIterableIterator
+     */
+    customGetPage?: GetPage<PaginateReturn<TResponse>[]>;
+}
+
+export declare interface ReceiptContentsOutput {
+    cert?: string;
+    leaf?: string;
+    leafComponents?: ReceiptLeafComponentsOutput;
     nodeId: string;
-    /** Merkle proof. */
-    proof: MerkleProofElement[];
-    /** Root of the Merkle tree at the time the transaction was recorded. */
-    root: string;
-    /** Signature by the node, with its certificate, over the Merkle root. */
+    proof: Array<ReceiptElementOutput>;
+    root?: string;
+    serviceEndorsements?: Array<string>;
     signature: string;
 }
 
-export declare interface RoleAssignment {
-    /** Represents an assignable role. */
-    roleName: ConfidentialLedgerUserRoleName;
-    /** Description of the role. */
-    description?: string;
+export declare interface ReceiptElementOutput {
+    left?: string;
+    right?: string;
+}
+
+export declare interface ReceiptLeafComponentsOutput {
+    claimsDigest?: string;
+    commitEvidence?: string;
+    writeSetDigest?: string;
 }
 
 export declare interface Routes {
     /** Resource for '/app/governance/constitution' has methods for the following verbs: get */
     (path: "/app/governance/constitution"): GetConstitution;
     /** Resource for '/app/governance/members' has methods for the following verbs: get */
-    (path: "/app/governance/members"): GetConsortiumMembers;
+    (path: "/app/governance/members"): ListConsortiumMembers;
     /** Resource for '/app/enclaveQuotes' has methods for the following verbs: get */
     (path: "/app/enclaveQuotes"): GetEnclaveQuotes;
+    /** Resource for '/app/collections' has methods for the following verbs: get */
+    (path: "/app/collections"): ListCollections;
     /** Resource for '/app/transactions' has methods for the following verbs: get, post */
-    (path: "/app/transactions"): PostLedgerEntry;
+    (path: "/app/transactions"): ListLedgerEntries;
     /** Resource for '/app/transactions/\{transactionId\}' has methods for the following verbs: get */
     (path: "/app/transactions/{transactionId}", transactionId: string): GetLedgerEntry;
     /** Resource for '/app/transactions/\{transactionId\}/receipt' has methods for the following verbs: get */
@@ -428,23 +563,20 @@ export declare interface Routes {
     /** Resource for '/app/transactions/current' has methods for the following verbs: get */
     (path: "/app/transactions/current"): GetCurrentLedgerEntry;
     /** Resource for '/app/users/\{userId\}' has methods for the following verbs: delete, get, patch */
-    (path: "/app/users/{userId}", userId: string): CreateOrUpdateUser;
+    (path: "/app/users/{userId}", userId: string): DeleteUser;
 }
 
-export declare interface TransactionReceipt {
-    /** A receipt certifying the transaction at the specified id. */
-    receipt?: ReceiptContents;
+export declare interface TransactionReceiptOutput {
+    receipt?: ReceiptContentsOutput;
     /** State of a ledger query. */
-    state: ConfidentialLedgerQueryState;
+    state: "Loading" | "Ready";
     /** A unique identifier for the state of the ledger. If returned as part of a LedgerEntry, it indicates the state from which the entry was read. */
     transactionId: string;
 }
 
-export declare type TransactionState = "Committed" | "Pending";
-
-export declare interface TransactionStatus {
+export declare interface TransactionStatusOutput {
     /** Represents the state of the transaction. */
-    state: TransactionState;
+    state: "Committed" | "Pending";
     /** A unique identifier for the state of the ledger. If returned as part of a LedgerEntry, it indicates the state from which the entry was read. */
     transactionId: string;
 }