Skip to content

reference.md

Latest commit

 

History

History
4024 lines (2881 loc) · 51.8 KB

reference.md

File metadata and controls

4024 lines (2881 loc) · 51.8 KB
Raw

Reference

Marketplace

client.Marketplace.GetMarketplaceAsync() -> WithRawResponseTask<MarketplaceObject>

📝 Description

Settings are changed in the dashboard, separately for test and live.

🔌 Usage

await client.Marketplace.GetMarketplaceAsync();

Sellers

client.Sellers.ListSellersAsync(ListSellersRequest { ... }) -> WithRawResponseTask<SellerList>

🔌 Usage

await client.Sellers.ListSellersAsync(new ListSellersRequest());

⚙️ Parameters

request: ListSellersRequest

client.Sellers.CreateSellerAsync(CreatePartyDto { ... }) -> WithRawResponseTask<SellerObject>

🔌 Usage

await client.Sellers.CreateSellerAsync(new CreatePartyDto { ExternalId = "external_id" });

⚙️ Parameters

request: CreatePartyDto

client.Sellers.GetSellerAsync(GetSellerRequest { ... }) -> WithRawResponseTask<SellerObject>

🔌 Usage

await client.Sellers.GetSellerAsync(new GetSellerRequest { Id = "id" });

⚙️ Parameters

request: GetSellerRequest

client.Sellers.EraseSellerAsync(EraseSellerRequest { ... }) -> WithRawResponseTask<SellerObject>

📝 Description

Removes the name, external id, metadata, storefront, and review text, and takes the listings down. Orders and reputation stay, without personal data.

🔌 Usage

await client.Sellers.EraseSellerAsync(new EraseSellerRequest { Id = "id" });

⚙️ Parameters

request: EraseSellerRequest

client.Sellers.UpdateSellerAsync(UpdateSellerRequest { ... }) -> WithRawResponseTask<SellerObject>

🔌 Usage

await client.Sellers.UpdateSellerAsync(
    new UpdateSellerRequest { Id = "id", Body = new UpdatePartyDto() }
);

⚙️ Parameters

request: UpdateSellerRequest

client.Sellers.PutStorefrontAsync(StorefrontDto { ... }) -> WithRawResponseTask<StorefrontObject>

🔌 Usage

await client.Sellers.PutStorefrontAsync(
    new StorefrontDto
    {
        Id = "id",
        Name = "name",
        Slug = "jane-templates",
    }
);

⚙️ Parameters

request: StorefrontDto

client.Sellers.CreateOnboardingLinkAsync(OnboardingLinkDto { ... }) -> WithRawResponseTask<OnboardingLinkObject>

📝 Description

The first link creates the seller's connected account on your Stripe account: Express, with Stripe collecting what the law requires, your platform paying Stripe's fees and bearing losses, and only transfers requested. Send the seller to the link; their payouts status follows as Stripe reports it.

🔌 Usage

await client.Sellers.CreateOnboardingLinkAsync(
    new OnboardingLinkDto
    {
        Id = "id",
        ReturnUrl = "return_url",
        RefreshUrl = "refresh_url",
    }
);

⚙️ Parameters

request: OnboardingLinkDto

client.Sellers.GetSellerProfileAsync(GetSellerProfileRequest { ... }) -> WithRawResponseTask<SellerProfileObject>

📝 Description

Callable with a publishable key. Shows only what a buyer may see.

🔌 Usage

await client.Sellers.GetSellerProfileAsync(new GetSellerProfileRequest { Id = "id" });

⚙️ Parameters

request: GetSellerProfileRequest

Buyers

client.Buyers.ListBuyersAsync(ListBuyersRequest { ... }) -> WithRawResponseTask<BuyerList>

🔌 Usage

await client.Buyers.ListBuyersAsync(new ListBuyersRequest());

⚙️ Parameters

request: ListBuyersRequest

client.Buyers.CreateBuyerAsync(CreatePartyDto { ... }) -> WithRawResponseTask<BuyerObject>

🔌 Usage

await client.Buyers.CreateBuyerAsync(new CreatePartyDto { ExternalId = "external_id" });

⚙️ Parameters

request: CreatePartyDto

client.Buyers.GetBuyerAsync(GetBuyerRequest { ... }) -> WithRawResponseTask<BuyerObject>

🔌 Usage

await client.Buyers.GetBuyerAsync(new GetBuyerRequest { Id = "id" });

⚙️ Parameters

request: GetBuyerRequest

client.Buyers.EraseBuyerAsync(EraseBuyerRequest { ... }) -> WithRawResponseTask<BuyerObject>

🔌 Usage

await client.Buyers.EraseBuyerAsync(new EraseBuyerRequest { Id = "id" });

⚙️ Parameters

request: EraseBuyerRequest

client.Buyers.UpdateBuyerAsync(UpdateBuyerRequest { ... }) -> WithRawResponseTask<BuyerObject>

🔌 Usage

await client.Buyers.UpdateBuyerAsync(
    new UpdateBuyerRequest { Id = "id", Body = new UpdatePartyDto() }
);

⚙️ Parameters

request: UpdateBuyerRequest

Categories

client.Categories.ListCategoriesAsync(ListCategoriesRequest { ... }) -> WithRawResponseTask<CategoryList>

🔌 Usage

await client.Categories.ListCategoriesAsync(new ListCategoriesRequest());

⚙️ Parameters

request: ListCategoriesRequest

client.Categories.CreateCategoryAsync(CreateCategoryDto { ... }) -> WithRawResponseTask<CategoryObject>

🔌 Usage

await client.Categories.CreateCategoryAsync(
    new CreateCategoryDto { Key = "ui-kits", Name = "name" }
);

⚙️ Parameters

request: CreateCategoryDto

client.Categories.GetCategoryAsync(GetCategoryRequest { ... }) -> WithRawResponseTask<CategoryObject>

🔌 Usage

await client.Categories.GetCategoryAsync(new GetCategoryRequest { Id = "id" });

⚙️ Parameters

request: GetCategoryRequest

client.Categories.UpdateCategoryAsync(UpdateCategoryDto { ... }) -> WithRawResponseTask<CategoryObject>

🔌 Usage

await client.Categories.UpdateCategoryAsync(new UpdateCategoryDto { Id = "id" });

⚙️ Parameters

request: UpdateCategoryDto

client.Categories.GetAttributeSchemaAsync(GetAttributeSchemaRequest { ... }) -> WithRawResponseTask<AttributeSchemaObject>

🔌 Usage

await client.Categories.GetAttributeSchemaAsync(new GetAttributeSchemaRequest { Id = "id" });

⚙️ Parameters

request: GetAttributeSchemaRequest

client.Categories.PutAttributeSchemaAsync(PutAttributeSchemaRequest { ... }) -> WithRawResponseTask<AttributeSchemaObject>

📝 Description

Refused if a listing already in the category would no longer fit.

🔌 Usage

await client.Categories.PutAttributeSchemaAsync(
    new PutAttributeSchemaRequest
    {
        Id = "id",
        Body = new AttributeSchemaObject
        {
            Attributes = new List<AttributeDefinitionObject>()
            {
                new AttributeDefinitionObject
                {
                    Key = "format",
                    Type = AttributeDefinitionObjectType.String,
                },
            },
        },
    }
);

⚙️ Parameters

request: PutAttributeSchemaRequest

Listings

client.Listings.ListListingsAsync(ListListingsRequest { ... }) -> WithRawResponseTask<ListingList>

📝 Description

With a publishable key, only published listings are listed.

🔌 Usage

await client.Listings.ListListingsAsync(new ListListingsRequest());

⚙️ Parameters

request: ListListingsRequest

client.Listings.CreateListingAsync(CreateListingDto { ... }) -> WithRawResponseTask<ListingObject>

🔌 Usage

await client.Listings.CreateListingAsync(
    new CreateListingDto
    {
        Seller = "sel_034XtPDs7UJ0TXzTsdaHZa",
        Title = "title",
        Price = new MoneyDto { Amount = 4900, Currency = "USD" },
    }
);

⚙️ Parameters

request: CreateListingDto

client.Listings.CreateListingsAsync(BulkCreateListingsDto { ... }) -> WithRawResponseTask<BulkListingsObject>

🔌 Usage

await client.Listings.CreateListingsAsync(
    new BulkCreateListingsDto
    {
        Listings = new List<CreateListingDto>()
        {
            new CreateListingDto
            {
                Seller = "sel_034XtPDs7UJ0TXzTsdaHZa",
                Title = "title",
                Price = new MoneyDto { Amount = 4900, Currency = "USD" },
            },
        },
    }
);

⚙️ Parameters

request: BulkCreateListingsDto

client.Listings.GetListingAsync(GetListingRequest { ... }) -> WithRawResponseTask<ListingObject>

📝 Description

With a publishable key, only a published listing can be retrieved.

🔌 Usage

await client.Listings.GetListingAsync(new GetListingRequest { Id = "id" });

⚙️ Parameters

request: GetListingRequest

client.Listings.UpdateListingAsync(UpdateListingDto { ... }) -> WithRawResponseTask<ListingObject>

🔌 Usage

await client.Listings.UpdateListingAsync(new UpdateListingDto { Id = "id" });

⚙️ Parameters

request: UpdateListingDto

client.Listings.PublishListingAsync(PublishListingRequest { ... }) -> WithRawResponseTask<ListingObject>

📝 Description

Needs an active seller, verified when seller verification is on, and a category that is not prohibited.

🔌 Usage

await client.Listings.PublishListingAsync(new PublishListingRequest { Id = "id" });

⚙️ Parameters

request: PublishListingRequest

client.Listings.UnpublishListingAsync(UnpublishListingRequest { ... }) -> WithRawResponseTask<ListingObject>

🔌 Usage

await client.Listings.UnpublishListingAsync(new UnpublishListingRequest { Id = "id" });

⚙️ Parameters

request: UnpublishListingRequest

client.Listings.RemoveListingAsync(RemoveListingDto { ... }) -> WithRawResponseTask<ListingObject>

🔌 Usage

await client.Listings.RemoveListingAsync(new RemoveListingDto { Id = "id", Reason = "reason" });

⚙️ Parameters

request: RemoveListingDto

client.Listings.ListMediaAsync(ListMediaRequest { ... }) -> WithRawResponseTask<MediaList>

🔌 Usage

await client.Listings.ListMediaAsync(new ListMediaRequest { Id = "id" });

⚙️ Parameters

request: ListMediaRequest

client.Listings.CreateMediaAsync(CreateMediaDto { ... }) -> WithRawResponseTask<MediaUploadObject>

📝 Description

Returns a signed URL, valid for 10 minutes. PUT the file there, then complete the upload. The file is stored under a path that begins with the marketplace id.

🔌 Usage

await client.Listings.CreateMediaAsync(
    new CreateMediaDto
    {
        Id = "id",
        ContentType = CreateMediaDtoContentType.ImageJpeg,
        SizeBytes = 1.1,
    }
);

⚙️ Parameters

request: CreateMediaDto

client.Listings.CompleteMediaAsync(CompleteMediaRequest { ... }) -> WithRawResponseTask<MediaObject>

📝 Description

Checks the stored file against the declared type and size.

🔌 Usage

await client.Listings.CompleteMediaAsync(new CompleteMediaRequest { Id = "id" });

⚙️ Parameters

request: CompleteMediaRequest

client.Listings.DeleteMediaAsync(DeleteMediaRequest { ... }) -> WithRawResponseTask<MediaObject>

🔌 Usage

await client.Listings.DeleteMediaAsync(new DeleteMediaRequest { Id = "id" });

⚙️ Parameters

request: DeleteMediaRequest

Search

client.Search.SearchListingsAsync(SearchListingsRequest { ... }) -> WithRawResponseTask<ListingList>

📝 Description

Full text over title and description, with filters and sorting. Only published listings with something available are returned. Callable with a publishable key.

🔌 Usage

await client.Search.SearchListingsAsync(new SearchListingsRequest());

⚙️ Parameters

request: SearchListingsRequest

Orders

client.Orders.ListOrdersAsync(ListOrdersRequest { ... }) -> WithRawResponseTask<OrderList>

🔌 Usage

await client.Orders.ListOrdersAsync(new ListOrdersRequest());

⚙️ Parameters

request: ListOrdersRequest

client.Orders.CreateOrderAsync(CreateOrderDto { ... }) -> WithRawResponseTask<OrderObject>

📝 Description

The buyer commits to buy. Quantity is reserved at once. With payments off the order is committed; with payments on it awaits payment.

🔌 Usage

await client.Orders.CreateOrderAsync(
    new CreateOrderDto
    {
        Listing = "lst_034XtPDs7UJ0TXzTsdaHZa",
        Buyer = "buy_034XtPDs7UJ0TXzTsdaHZa",
    }
);

⚙️ Parameters

request: CreateOrderDto

client.Orders.GetOrderAsync(GetOrderRequest { ... }) -> WithRawResponseTask<OrderObject>

🔌 Usage

await client.Orders.GetOrderAsync(new GetOrderRequest { Id = "id" });

⚙️ Parameters

request: GetOrderRequest

client.Orders.ListOrderEventsAsync(ListOrderEventsRequest { ... }) -> WithRawResponseTask<OrderEventList>

🔌 Usage

await client.Orders.ListOrderEventsAsync(new ListOrderEventsRequest { Id = "id" });

⚙️ Parameters

request: ListOrderEventsRequest

client.Orders.ClaimOrderAsync(ClaimOrderRequest { ... }) -> WithRawResponseTask<OrderObject>

📝 Description

Called from your server. actor says which end user is acting; we check they are a party to the order and may make this transition.

🔌 Usage

await client.Orders.ClaimOrderAsync(
    new ClaimOrderRequest
    {
        Id = "id",
        Body = new ActorDto { Actor = "buy_034XtPDs7UJ0TXzTsdaHZa" },
    }
);

⚙️ Parameters

request: ClaimOrderRequest

client.Orders.ConfirmOrderAsync(ConfirmOrderRequest { ... }) -> WithRawResponseTask<OrderObject>

📝 Description

Called from your server. actor says which end user is acting; we check they are a party to the order and may make this transition.

🔌 Usage

await client.Orders.ConfirmOrderAsync(
    new ConfirmOrderRequest
    {
        Id = "id",
        Body = new ActorDto { Actor = "buy_034XtPDs7UJ0TXzTsdaHZa" },
    }
);

⚙️ Parameters

request: ConfirmOrderRequest

client.Orders.BackOutOfOrderAsync(BackOutOfOrderRequest { ... }) -> WithRawResponseTask<OrderObject>

📝 Description

Called from your server. actor says which end user is acting; we check they are a party to the order and may make this transition. Writes a backed_out reputation event against the actor.

🔌 Usage

await client.Orders.BackOutOfOrderAsync(
    new BackOutOfOrderRequest
    {
        Id = "id",
        Body = new ActorDto { Actor = "buy_034XtPDs7UJ0TXzTsdaHZa" },
    }
);

⚙️ Parameters

request: BackOutOfOrderRequest

client.Orders.ProposeCancelAsync(ProposeCancelRequest { ... }) -> WithRawResponseTask<OrderObject>

📝 Description

Called from your server. actor says which end user is acting; we check they are a party to the order and may make this transition. The other party can accept within the agreement window. A declined or lapsed proposal changes nothing.

🔌 Usage

await client.Orders.ProposeCancelAsync(
    new ProposeCancelRequest
    {
        Id = "id",
        Body = new ActorDto { Actor = "buy_034XtPDs7UJ0TXzTsdaHZa" },
    }
);

⚙️ Parameters

request: ProposeCancelRequest

client.Orders.AcceptCancelAsync(AcceptCancelRequest { ... }) -> WithRawResponseTask<OrderObject>

📝 Description

Called from your server. actor says which end user is acting; we check they are a party to the order and may make this transition.

🔌 Usage

await client.Orders.AcceptCancelAsync(
    new AcceptCancelRequest
    {
        Id = "id",
        Body = new ActorDto { Actor = "buy_034XtPDs7UJ0TXzTsdaHZa" },
    }
);

⚙️ Parameters

request: AcceptCancelRequest

client.Orders.DeclineCancelAsync(DeclineCancelRequest { ... }) -> WithRawResponseTask<OrderObject>

📝 Description

Called from your server. actor says which end user is acting; we check they are a party to the order and may make this transition.

🔌 Usage

await client.Orders.DeclineCancelAsync(
    new DeclineCancelRequest
    {
        Id = "id",
        Body = new ActorDto { Actor = "buy_034XtPDs7UJ0TXzTsdaHZa" },
    }
);

⚙️ Parameters

request: DeclineCancelRequest

client.Orders.ListOrderReviewsAsync(ListOrderReviewsRequest { ... }) -> WithRawResponseTask<ReviewList>

🔌 Usage

await client.Orders.ListOrderReviewsAsync(new ListOrderReviewsRequest { Id = "id" });

⚙️ Parameters

request: ListOrderReviewsRequest

client.Orders.CreateReviewAsync(CreateReviewDto { ... }) -> WithRawResponseTask<ReviewObject>

📝 Description

Called from your server. actor says which end user is acting; we check they are a party to the order and may make this transition. Only on a completed order, inside the review window, once per party. Hidden until both have reviewed or the window closes.

🔌 Usage

await client.Orders.CreateReviewAsync(
    new CreateReviewDto
    {
        Id = "id",
        Actor = "buy_034XtPDs7UJ0TXzTsdaHZa",
        Rating = 1.1,
    }
);

⚙️ Parameters

request: CreateReviewDto

Reviews

client.Reviews.ListReviewsAsync(ListReviewsRequest { ... }) -> WithRawResponseTask<ReviewList>

🔌 Usage

await client.Reviews.ListReviewsAsync(new ListReviewsRequest { Subject = "subject" });

⚙️ Parameters

request: ListReviewsRequest

client.Reviews.GetReviewAsync(GetReviewRequest { ... }) -> WithRawResponseTask<ReviewObject>

🔌 Usage

await client.Reviews.GetReviewAsync(new GetReviewRequest { Id = "id" });

⚙️ Parameters

request: GetReviewRequest

Reputation

client.Reputation.ListReputationEventsAsync(ListReputationEventsRequest { ... }) -> WithRawResponseTask<ReputationEventList>

🔌 Usage

await client.Reputation.ListReputationEventsAsync(
    new ListReputationEventsRequest { Party = "party" }
);

⚙️ Parameters

request: ListReputationEventsRequest

client.Reputation.VoidReputationEventAsync(VoidDto { ... }) -> WithRawResponseTask<ReputationEventObject>

📝 Description

For the customer's team. Writes a second event pointing at the first. The voided event stops counting. Nothing is deleted.

🔌 Usage

await client.Reputation.VoidReputationEventAsync(new VoidDto { Id = "id", Reason = "reason" });

⚙️ Parameters

request: VoidDto

Payments

client.Payments.ListPaymentsAsync(ListPaymentsRequest { ... }) -> WithRawResponseTask<PaymentList>

🔌 Usage

await client.Payments.ListPaymentsAsync(new ListPaymentsRequest());

⚙️ Parameters

request: ListPaymentsRequest

client.Payments.GetPaymentAsync(GetPaymentRequest { ... }) -> WithRawResponseTask<PaymentObject>

🔌 Usage

await client.Payments.GetPaymentAsync(new GetPaymentRequest { Id = "id" });

⚙️ Parameters

request: GetPaymentRequest

client.Payments.UpdatePaymentAsync(UpdatePaymentRequest { ... }) -> WithRawResponseTask<PaymentObject>

🔌 Usage

await client.Payments.UpdatePaymentAsync(
    new UpdatePaymentRequest
    {
        Id = "id",
        Body = new UpdateMetadataDto
        {
            Metadata = new Dictionary<string, string>() { { "key", "value" } },
        },
    }
);

⚙️ Parameters

request: UpdatePaymentRequest

client.Payments.RetryPaymentReleaseAsync(RetryPaymentReleaseRequest { ... }) -> WithRawResponseTask<PaymentObject>

📝 Description

For a release that failed, for example because the seller could not yet receive transfers. A release is also tried again by itself when the seller becomes able to receive payouts.

🔌 Usage

await client.Payments.RetryPaymentReleaseAsync(new RetryPaymentReleaseRequest { Id = "id" });

⚙️ Parameters

request: RetryPaymentReleaseRequest

client.Payments.ListRefundsAsync(ListRefundsRequest { ... }) -> WithRawResponseTask<RefundList>

🔌 Usage

await client.Payments.ListRefundsAsync(new ListRefundsRequest());

⚙️ Parameters

request: ListRefundsRequest

client.Payments.CreateRefundAsync(CreateRefundDto { ... }) -> WithRawResponseTask<RefundObject>

📝 Description

Recorded at once with status pending, then made at Stripe. If the seller's share was already released, the transfer is reversed in the same proportion, so your fee is given back in proportion too.

🔌 Usage

await client.Payments.CreateRefundAsync(new CreateRefundDto());

⚙️ Parameters

request: CreateRefundDto

client.Payments.GetRefundAsync(GetRefundRequest { ... }) -> WithRawResponseTask<RefundObject>

🔌 Usage

await client.Payments.GetRefundAsync(new GetRefundRequest { Id = "id" });

⚙️ Parameters

request: GetRefundRequest

client.Payments.UpdateRefundAsync(UpdateRefundRequest { ... }) -> WithRawResponseTask<RefundObject>

🔌 Usage

await client.Payments.UpdateRefundAsync(
    new UpdateRefundRequest
    {
        Id = "id",
        Body = new UpdateMetadataDto
        {
            Metadata = new Dictionary<string, string>() { { "key", "value" } },
        },
    }
);

⚙️ Parameters

request: UpdateRefundRequest

Trust

client.Trust.CreateVerificationAsync(CreateVerificationDto { ... }) -> WithRawResponseTask<VerificationObject>

📝 Description

Creates a Stripe Identity session on your Stripe account and returns its page, once. Only the outcome and the session id are kept; no document image or document data. When seller verification is on, a seller can publish only once verified.

🔌 Usage

await client.Trust.CreateVerificationAsync(new CreateVerificationDto { Id = "id" });

⚙️ Parameters

request: CreateVerificationDto

client.Trust.ListVerificationsAsync(ListVerificationsRequest { ... }) -> WithRawResponseTask<VerificationList>

🔌 Usage

await client.Trust.ListVerificationsAsync(new ListVerificationsRequest());

⚙️ Parameters

request: ListVerificationsRequest

client.Trust.GetVerificationAsync(GetVerificationRequest { ... }) -> WithRawResponseTask<VerificationObject>

🔌 Usage

await client.Trust.GetVerificationAsync(new GetVerificationRequest { Id = "id" });

⚙️ Parameters

request: GetVerificationRequest

client.Trust.CancelVerificationAsync(CancelVerificationRequest { ... }) -> WithRawResponseTask<VerificationObject>

🔌 Usage

await client.Trust.CancelVerificationAsync(new CancelVerificationRequest { Id = "id" });

⚙️ Parameters

request: CancelVerificationRequest

client.Trust.ListDisputesAsync(ListDisputesRequest { ... }) -> WithRawResponseTask<DisputeList>

📝 Description

Filter by stage for a queue.

🔌 Usage

await client.Trust.ListDisputesAsync(new ListDisputesRequest());

⚙️ Parameters

request: ListDisputesRequest

client.Trust.GetDisputeAsync(GetDisputeRequest { ... }) -> WithRawResponseTask<DisputeObject>

🔌 Usage

await client.Trust.GetDisputeAsync(new GetDisputeRequest { Id = "id" });

⚙️ Parameters

request: GetDisputeRequest

client.Trust.ListDisputeEvidenceAsync(ListDisputeEvidenceRequest { ... }) -> WithRawResponseTask<DisputeEvidenceList>

🔌 Usage

await client.Trust.ListDisputeEvidenceAsync(new ListDisputeEvidenceRequest { Id = "id" });

⚙️ Parameters

request: ListDisputeEvidenceRequest

client.Trust.AddDisputeEvidenceAsync(AddEvidenceDto { ... }) -> WithRawResponseTask<DisputeEvidenceObject>

📝 Description

Only while the dispute is in its evidence stage.

🔌 Usage

await client.Trust.AddDisputeEvidenceAsync(
    new AddEvidenceDto
    {
        Id = "id",
        Actor = "actor",
        Body = "body",
    }
);

⚙️ Parameters

request: AddEvidenceDto

client.Trust.CloseDisputeEvidenceAsync(CloseDisputeEvidenceRequest { ... }) -> WithRawResponseTask<DisputeObject>

🔌 Usage

await client.Trust.CloseDisputeEvidenceAsync(new CloseDisputeEvidenceRequest { Id = "id" });

⚙️ Parameters

request: CloseDisputeEvidenceRequest

client.Trust.DecideDisputeAsync(DecideDisputeDto { ... }) -> WithRawResponseTask<DisputeObject>

📝 Description

Your team's decision: who it went against, in writing, and with payments on, how much goes back to the buyer. On a claimed order, deciding against the party who disputed upholds the claim and completes the order; deciding against the claimant cancels it.

🔌 Usage

await client.Trust.DecideDisputeAsync(
    new DecideDisputeDto
    {
        Id = "id",
        Against = DecideDisputeDtoAgainst.Buyer,
        Note = "note",
    }
);

⚙️ Parameters

request: DecideDisputeDto

client.Trust.OpenDisputeAsync(OpenDisputeDto { ... }) -> WithRawResponseTask<DisputeObject>

📝 Description

On a claimed order, by the party who did not claim: the order becomes disputed. On a completed order, by either party inside the dispute window: the order stays completed.

🔌 Usage

await client.Trust.OpenDisputeAsync(
    new OpenDisputeDto
    {
        Id = "id",
        Actor = "buy_034XtPDs7UJ0TXzTsdaHZa",
        Reason = "reason",
    }
);

⚙️ Parameters

request: OpenDisputeDto

Moderation

client.Moderation.ListFlagsAsync(ListFlagsRequest { ... }) -> WithRawResponseTask<FlagList>

🔌 Usage

await client.Moderation.ListFlagsAsync(new ListFlagsRequest());

⚙️ Parameters

request: ListFlagsRequest

client.Moderation.CreateFlagAsync(CreateFlagDto { ... }) -> WithRawResponseTask<FlagObject>

📝 Description

On behalf of the end user who reported it.

🔌 Usage

await client.Moderation.CreateFlagAsync(
    new CreateFlagDto
    {
        Target = "lst_034XtPDs7UJ0TXzTsdaHZa",
        Reporter = "buy_034XtPDs7UJ0TXzTsdaHZa",
        Reason = CreateFlagDtoReason.ProhibitedItem,
    }
);

⚙️ Parameters

request: CreateFlagDto

client.Moderation.GetFlagAsync(GetFlagRequest { ... }) -> WithRawResponseTask<FlagObject>

🔌 Usage

await client.Moderation.GetFlagAsync(new GetFlagRequest { Id = "id" });

⚙️ Parameters

request: GetFlagRequest

client.Moderation.GetModerationQueueAsync(GetModerationQueueRequest { ... }) -> WithRawResponseTask<ModerationQueueObject>

🔌 Usage

await client.Moderation.GetModerationQueueAsync(new GetModerationQueueRequest());

⚙️ Parameters

request: GetModerationQueueRequest

client.Moderation.ListModerationActionsAsync(ListModerationActionsRequest { ... }) -> WithRawResponseTask<ModerationActionList>

🔌 Usage

await client.Moderation.ListModerationActionsAsync(new ListModerationActionsRequest());

⚙️ Parameters

request: ListModerationActionsRequest

client.Moderation.CreateModerationActionAsync(CreateModerationActionDto { ... }) -> WithRawResponseTask<ModerationActionObject>

📝 Description

Resolves the target's open flags and logs who acted and why.

🔌 Usage

await client.Moderation.CreateModerationActionAsync(
    new CreateModerationActionDto
    {
        Target = "target",
        Action = CreateModerationActionDtoAction.Dismiss,
        Reason = "reason",
        Actor = "actor",
    }
);

⚙️ Parameters

request: CreateModerationActionDto

Webhooks

client.Webhooks.ListWebhookEndpointsAsync(ListWebhookEndpointsRequest { ... }) -> WithRawResponseTask<WebhookEndpointList>

🔌 Usage

await client.Webhooks.ListWebhookEndpointsAsync(new ListWebhookEndpointsRequest());

⚙️ Parameters

request: ListWebhookEndpointsRequest

client.Webhooks.CreateWebhookEndpointAsync(CreateWebhookEndpointDto { ... }) -> WithRawResponseTask<WebhookEndpointObject>

📝 Description

Returns the signing secret, once. Every delivery carries MarketSDK-Signature: t=<time>,v1=<HMAC-SHA256 of "<time>.<body>">.

🔌 Usage

await client.Webhooks.CreateWebhookEndpointAsync(
    new CreateWebhookEndpointDto
    {
        Url = "https://shop.example/marketsdk/webhooks",
        EnabledEvents = new List<CreateWebhookEndpointDtoEnabledEventsItem>()
        {
            CreateWebhookEndpointDtoEnabledEventsItem.All,
        },
    }
);

⚙️ Parameters

request: CreateWebhookEndpointDto

client.Webhooks.GetWebhookEndpointAsync(GetWebhookEndpointRequest { ... }) -> WithRawResponseTask<WebhookEndpointObject>

🔌 Usage

await client.Webhooks.GetWebhookEndpointAsync(new GetWebhookEndpointRequest { Id = "id" });

⚙️ Parameters

request: GetWebhookEndpointRequest

client.Webhooks.DeleteWebhookEndpointAsync(DeleteWebhookEndpointRequest { ... }) -> WithRawResponseTask<DeletedWebhookEndpointObject>

🔌 Usage

await client.Webhooks.DeleteWebhookEndpointAsync(new DeleteWebhookEndpointRequest { Id = "id" });

⚙️ Parameters

request: DeleteWebhookEndpointRequest

client.Webhooks.UpdateWebhookEndpointAsync(UpdateWebhookEndpointDto { ... }) -> WithRawResponseTask<WebhookEndpointObject>

🔌 Usage

await client.Webhooks.UpdateWebhookEndpointAsync(new UpdateWebhookEndpointDto { Id = "id" });

⚙️ Parameters

request: UpdateWebhookEndpointDto

client.Webhooks.RotateWebhookSecretAsync(RotateWebhookSecretRequest { ... }) -> WithRawResponseTask<WebhookEndpointObject>

📝 Description

Returns the new secret, once. The old one stops at once.

🔌 Usage

await client.Webhooks.RotateWebhookSecretAsync(new RotateWebhookSecretRequest { Id = "id" });

⚙️ Parameters

request: RotateWebhookSecretRequest

client.Webhooks.ListWebhookDeliveriesAsync(ListWebhookDeliveriesRequest { ... }) -> WithRawResponseTask<WebhookDeliveryList>

🔌 Usage

await client.Webhooks.ListWebhookDeliveriesAsync(new ListWebhookDeliveriesRequest());

⚙️ Parameters

request: ListWebhookDeliveriesRequest

client.Webhooks.GetWebhookDeliveryAsync(GetWebhookDeliveryRequest { ... }) -> WithRawResponseTask<WebhookDeliveryObject>

🔌 Usage

await client.Webhooks.GetWebhookDeliveryAsync(new GetWebhookDeliveryRequest { Id = "id" });

⚙️ Parameters

request: GetWebhookDeliveryRequest

client.Webhooks.ReplayWebhookDeliveryAsync(ReplayWebhookDeliveryRequest { ... }) -> WithRawResponseTask<WebhookDeliveryObject>

📝 Description

Creates a new delivery of the same event to the same endpoint.

🔌 Usage

await client.Webhooks.ReplayWebhookDeliveryAsync(new ReplayWebhookDeliveryRequest { Id = "id" });

⚙️ Parameters

request: ReplayWebhookDeliveryRequest

client.Webhooks.ListEventsAsync(ListEventsRequest { ... }) -> WithRawResponseTask<EventList>

🔌 Usage

await client.Webhooks.ListEventsAsync(new ListEventsRequest());

⚙️ Parameters

request: ListEventsRequest

client.Webhooks.GetEventAsync(GetEventRequest { ... }) -> WithRawResponseTask<EventObject>

🔌 Usage

await client.Webhooks.GetEventAsync(new GetEventRequest { Id = "id" });

⚙️ Parameters

request: GetEventRequest