@aws-sdk/client-marketplace-agreement 3.463.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,458 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { MarketplaceAgreementServiceException as __BaseException } from "./MarketplaceAgreementServiceException";
+export interface ByolPricingTerm {
+  type?: string;
+}
+export interface Dimension {
+  dimensionKey: string | undefined;
+  dimensionValue: number | undefined;
+}
+export interface ConfigurableUpfrontPricingTermConfiguration {
+  selectorValue: string | undefined;
+  dimensions: Dimension[] | undefined;
+}
+export interface Constraints {
+  multipleDimensionSelection?: string;
+  quantityConfiguration?: string;
+}
+export interface RateCardItem {
+  dimensionKey?: string;
+  price?: string;
+}
+export interface Selector {
+  type?: string;
+  value?: string;
+}
+export interface ConfigurableUpfrontRateCardItem {
+  selector?: Selector;
+  constraints?: Constraints;
+  rateCard?: RateCardItem[];
+}
+export interface ConfigurableUpfrontPricingTerm {
+  type?: string;
+  currencyCode?: string;
+  rateCards?: ConfigurableUpfrontRateCardItem[];
+  configuration?: ConfigurableUpfrontPricingTermConfiguration;
+}
+export interface GrantItem {
+  dimensionKey?: string;
+  maxQuantity?: number;
+}
+export interface FixedUpfrontPricingTerm {
+  type?: string;
+  currencyCode?: string;
+  duration?: string;
+  price?: string;
+  grants?: GrantItem[];
+}
+export interface FreeTrialPricingTerm {
+  type?: string;
+  duration?: string;
+  grants?: GrantItem[];
+}
+export interface DocumentItem {
+  type?: string;
+  url?: string;
+  version?: string;
+}
+export interface LegalTerm {
+  type?: string;
+  documents?: DocumentItem[];
+}
+export interface ScheduleItem {
+  chargeDate?: Date;
+  chargeAmount?: string;
+}
+export interface PaymentScheduleTerm {
+  type?: string;
+  currencyCode?: string;
+  schedule?: ScheduleItem[];
+}
+export interface RecurringPaymentTerm {
+  type?: string;
+  currencyCode?: string;
+  billingPeriod?: string;
+  price?: string;
+}
+export interface RenewalTermConfiguration {
+  enableAutoRenew: boolean | undefined;
+}
+export interface RenewalTerm {
+  type?: string;
+  configuration?: RenewalTermConfiguration;
+}
+export interface SupportTerm {
+  type?: string;
+  refundPolicy?: string;
+}
+export interface UsageBasedRateCardItem {
+  rateCard?: RateCardItem[];
+}
+export interface UsageBasedPricingTerm {
+  type?: string;
+  currencyCode?: string;
+  rateCards?: UsageBasedRateCardItem[];
+}
+export interface ValidityTerm {
+  type?: string;
+  agreementDuration?: string;
+  agreementStartDate?: Date;
+  agreementEndDate?: Date;
+}
+export type AcceptedTerm =
+  | AcceptedTerm.ByolPricingTermMember
+  | AcceptedTerm.ConfigurableUpfrontPricingTermMember
+  | AcceptedTerm.FixedUpfrontPricingTermMember
+  | AcceptedTerm.FreeTrialPricingTermMember
+  | AcceptedTerm.LegalTermMember
+  | AcceptedTerm.PaymentScheduleTermMember
+  | AcceptedTerm.RecurringPaymentTermMember
+  | AcceptedTerm.RenewalTermMember
+  | AcceptedTerm.SupportTermMember
+  | AcceptedTerm.UsageBasedPricingTermMember
+  | AcceptedTerm.ValidityTermMember
+  | AcceptedTerm.$UnknownMember;
+export declare namespace AcceptedTerm {
+  interface LegalTermMember {
+    legalTerm: LegalTerm;
+    supportTerm?: never;
+    renewalTerm?: never;
+    usageBasedPricingTerm?: never;
+    configurableUpfrontPricingTerm?: never;
+    byolPricingTerm?: never;
+    recurringPaymentTerm?: never;
+    validityTerm?: never;
+    paymentScheduleTerm?: never;
+    freeTrialPricingTerm?: never;
+    fixedUpfrontPricingTerm?: never;
+    $unknown?: never;
+  }
+  interface SupportTermMember {
+    legalTerm?: never;
+    supportTerm: SupportTerm;
+    renewalTerm?: never;
+    usageBasedPricingTerm?: never;
+    configurableUpfrontPricingTerm?: never;
+    byolPricingTerm?: never;
+    recurringPaymentTerm?: never;
+    validityTerm?: never;
+    paymentScheduleTerm?: never;
+    freeTrialPricingTerm?: never;
+    fixedUpfrontPricingTerm?: never;
+    $unknown?: never;
+  }
+  interface RenewalTermMember {
+    legalTerm?: never;
+    supportTerm?: never;
+    renewalTerm: RenewalTerm;
+    usageBasedPricingTerm?: never;
+    configurableUpfrontPricingTerm?: never;
+    byolPricingTerm?: never;
+    recurringPaymentTerm?: never;
+    validityTerm?: never;
+    paymentScheduleTerm?: never;
+    freeTrialPricingTerm?: never;
+    fixedUpfrontPricingTerm?: never;
+    $unknown?: never;
+  }
+  interface UsageBasedPricingTermMember {
+    legalTerm?: never;
+    supportTerm?: never;
+    renewalTerm?: never;
+    usageBasedPricingTerm: UsageBasedPricingTerm;
+    configurableUpfrontPricingTerm?: never;
+    byolPricingTerm?: never;
+    recurringPaymentTerm?: never;
+    validityTerm?: never;
+    paymentScheduleTerm?: never;
+    freeTrialPricingTerm?: never;
+    fixedUpfrontPricingTerm?: never;
+    $unknown?: never;
+  }
+  interface ConfigurableUpfrontPricingTermMember {
+    legalTerm?: never;
+    supportTerm?: never;
+    renewalTerm?: never;
+    usageBasedPricingTerm?: never;
+    configurableUpfrontPricingTerm: ConfigurableUpfrontPricingTerm;
+    byolPricingTerm?: never;
+    recurringPaymentTerm?: never;
+    validityTerm?: never;
+    paymentScheduleTerm?: never;
+    freeTrialPricingTerm?: never;
+    fixedUpfrontPricingTerm?: never;
+    $unknown?: never;
+  }
+  interface ByolPricingTermMember {
+    legalTerm?: never;
+    supportTerm?: never;
+    renewalTerm?: never;
+    usageBasedPricingTerm?: never;
+    configurableUpfrontPricingTerm?: never;
+    byolPricingTerm: ByolPricingTerm;
+    recurringPaymentTerm?: never;
+    validityTerm?: never;
+    paymentScheduleTerm?: never;
+    freeTrialPricingTerm?: never;
+    fixedUpfrontPricingTerm?: never;
+    $unknown?: never;
+  }
+  interface RecurringPaymentTermMember {
+    legalTerm?: never;
+    supportTerm?: never;
+    renewalTerm?: never;
+    usageBasedPricingTerm?: never;
+    configurableUpfrontPricingTerm?: never;
+    byolPricingTerm?: never;
+    recurringPaymentTerm: RecurringPaymentTerm;
+    validityTerm?: never;
+    paymentScheduleTerm?: never;
+    freeTrialPricingTerm?: never;
+    fixedUpfrontPricingTerm?: never;
+    $unknown?: never;
+  }
+  interface ValidityTermMember {
+    legalTerm?: never;
+    supportTerm?: never;
+    renewalTerm?: never;
+    usageBasedPricingTerm?: never;
+    configurableUpfrontPricingTerm?: never;
+    byolPricingTerm?: never;
+    recurringPaymentTerm?: never;
+    validityTerm: ValidityTerm;
+    paymentScheduleTerm?: never;
+    freeTrialPricingTerm?: never;
+    fixedUpfrontPricingTerm?: never;
+    $unknown?: never;
+  }
+  interface PaymentScheduleTermMember {
+    legalTerm?: never;
+    supportTerm?: never;
+    renewalTerm?: never;
+    usageBasedPricingTerm?: never;
+    configurableUpfrontPricingTerm?: never;
+    byolPricingTerm?: never;
+    recurringPaymentTerm?: never;
+    validityTerm?: never;
+    paymentScheduleTerm: PaymentScheduleTerm;
+    freeTrialPricingTerm?: never;
+    fixedUpfrontPricingTerm?: never;
+    $unknown?: never;
+  }
+  interface FreeTrialPricingTermMember {
+    legalTerm?: never;
+    supportTerm?: never;
+    renewalTerm?: never;
+    usageBasedPricingTerm?: never;
+    configurableUpfrontPricingTerm?: never;
+    byolPricingTerm?: never;
+    recurringPaymentTerm?: never;
+    validityTerm?: never;
+    paymentScheduleTerm?: never;
+    freeTrialPricingTerm: FreeTrialPricingTerm;
+    fixedUpfrontPricingTerm?: never;
+    $unknown?: never;
+  }
+  interface FixedUpfrontPricingTermMember {
+    legalTerm?: never;
+    supportTerm?: never;
+    renewalTerm?: never;
+    usageBasedPricingTerm?: never;
+    configurableUpfrontPricingTerm?: never;
+    byolPricingTerm?: never;
+    recurringPaymentTerm?: never;
+    validityTerm?: never;
+    paymentScheduleTerm?: never;
+    freeTrialPricingTerm?: never;
+    fixedUpfrontPricingTerm: FixedUpfrontPricingTerm;
+    $unknown?: never;
+  }
+  interface $UnknownMember {
+    legalTerm?: never;
+    supportTerm?: never;
+    renewalTerm?: never;
+    usageBasedPricingTerm?: never;
+    configurableUpfrontPricingTerm?: never;
+    byolPricingTerm?: never;
+    recurringPaymentTerm?: never;
+    validityTerm?: never;
+    paymentScheduleTerm?: never;
+    freeTrialPricingTerm?: never;
+    fixedUpfrontPricingTerm?: never;
+    $unknown: [string, any];
+  }
+  interface Visitor<T> {
+    legalTerm: (value: LegalTerm) => T;
+    supportTerm: (value: SupportTerm) => T;
+    renewalTerm: (value: RenewalTerm) => T;
+    usageBasedPricingTerm: (value: UsageBasedPricingTerm) => T;
+    configurableUpfrontPricingTerm: (
+      value: ConfigurableUpfrontPricingTerm
+    ) => T;
+    byolPricingTerm: (value: ByolPricingTerm) => T;
+    recurringPaymentTerm: (value: RecurringPaymentTerm) => T;
+    validityTerm: (value: ValidityTerm) => T;
+    paymentScheduleTerm: (value: PaymentScheduleTerm) => T;
+    freeTrialPricingTerm: (value: FreeTrialPricingTerm) => T;
+    fixedUpfrontPricingTerm: (value: FixedUpfrontPricingTerm) => T;
+    _: (name: string, value: any) => T;
+  }
+  const visit: <T>(value: AcceptedTerm, visitor: Visitor<T>) => T;
+}
+export interface Acceptor {
+  accountId?: string;
+}
+export declare class AccessDeniedException extends __BaseException {
+  readonly name: "AccessDeniedException";
+  readonly $fault: "client";
+  requestId?: string;
+  constructor(
+    opts: __ExceptionOptionType<AccessDeniedException, __BaseException>
+  );
+}
+export declare const AgreementStatus: {
+  readonly ACTIVE: "ACTIVE";
+  readonly ARCHIVED: "ARCHIVED";
+  readonly CANCELLED: "CANCELLED";
+  readonly EXPIRED: "EXPIRED";
+  readonly RENEWED: "RENEWED";
+  readonly REPLACED: "REPLACED";
+  readonly ROLLED_BACK: "ROLLED_BACK";
+  readonly SUPERSEDED: "SUPERSEDED";
+  readonly TERMINATED: "TERMINATED";
+};
+export type AgreementStatus =
+  (typeof AgreementStatus)[keyof typeof AgreementStatus];
+export interface Resource {
+  id?: string;
+  type?: string;
+}
+export interface ProposalSummary {
+  resources?: Resource[];
+  offerId?: string;
+}
+export interface Proposer {
+  accountId?: string;
+}
+export interface AgreementViewSummary {
+  agreementId?: string;
+  acceptanceTime?: Date;
+  startTime?: Date;
+  endTime?: Date;
+  agreementType?: string;
+  acceptor?: Acceptor;
+  proposer?: Proposer;
+  proposalSummary?: ProposalSummary;
+  status?: AgreementStatus;
+}
+export interface DescribeAgreementInput {
+  agreementId: string | undefined;
+}
+export interface EstimatedCharges {
+  currencyCode?: string;
+  agreementValue?: string;
+}
+export interface DescribeAgreementOutput {
+  agreementId?: string;
+  acceptor?: Acceptor;
+  proposer?: Proposer;
+  startTime?: Date;
+  endTime?: Date;
+  acceptanceTime?: Date;
+  agreementType?: string;
+  estimatedCharges?: EstimatedCharges;
+  proposalSummary?: ProposalSummary;
+  status?: AgreementStatus;
+}
+export declare class InternalServerException extends __BaseException {
+  readonly name: "InternalServerException";
+  readonly $fault: "server";
+  requestId?: string;
+  constructor(
+    opts: __ExceptionOptionType<InternalServerException, __BaseException>
+  );
+}
+export declare const ResourceType: {
+  readonly AGREEMENT: "Agreement";
+};
+export type ResourceType = (typeof ResourceType)[keyof typeof ResourceType];
+export declare class ResourceNotFoundException extends __BaseException {
+  readonly name: "ResourceNotFoundException";
+  readonly $fault: "client";
+  requestId?: string;
+  resourceId?: string;
+  resourceType?: ResourceType;
+  constructor(
+    opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>
+  );
+}
+export declare class ThrottlingException extends __BaseException {
+  readonly name: "ThrottlingException";
+  readonly $fault: "client";
+  requestId?: string;
+  constructor(
+    opts: __ExceptionOptionType<ThrottlingException, __BaseException>
+  );
+}
+export interface ValidationExceptionField {
+  name: string | undefined;
+  message: string | undefined;
+}
+export declare const ValidationExceptionReason: {
+  readonly INVALID_AGREEMENT_ID: "INVALID_AGREEMENT_ID";
+  readonly INVALID_CATALOG: "INVALID_CATALOG";
+  readonly INVALID_FILTER_NAME: "INVALID_FILTER_NAME";
+  readonly INVALID_FILTER_VALUES: "INVALID_FILTER_VALUES";
+  readonly INVALID_MAX_RESULTS: "INVALID_MAX_RESULTS";
+  readonly INVALID_NEXT_TOKEN: "INVALID_NEXT_TOKEN";
+  readonly INVALID_SORT_BY: "INVALID_SORT_BY";
+  readonly INVALID_SORT_ORDER: "INVALID_SORT_ORDER";
+  readonly MISSING_AGREEMENT_ID: "MISSING_AGREEMENT_ID";
+  readonly OTHER: "OTHER";
+  readonly UNSUPPORTED_FILTERS: "UNSUPPORTED_FILTERS";
+};
+export type ValidationExceptionReason =
+  (typeof ValidationExceptionReason)[keyof typeof ValidationExceptionReason];
+export declare class ValidationException extends __BaseException {
+  readonly name: "ValidationException";
+  readonly $fault: "client";
+  requestId?: string;
+  reason?: ValidationExceptionReason;
+  fields?: ValidationExceptionField[];
+  constructor(
+    opts: __ExceptionOptionType<ValidationException, __BaseException>
+  );
+}
+export interface GetAgreementTermsInput {
+  agreementId: string | undefined;
+  maxResults?: number;
+  nextToken?: string;
+}
+export interface GetAgreementTermsOutput {
+  acceptedTerms?: AcceptedTerm[];
+  nextToken?: string;
+}
+export interface Filter {
+  name?: string;
+  values?: string[];
+}
+export declare const SortOrder: {
+  readonly ASCENDING: "ASCENDING";
+  readonly DESCENDING: "DESCENDING";
+};
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder];
+export interface Sort {
+  sortBy?: string;
+  sortOrder?: SortOrder;
+}
+export interface SearchAgreementsInput {
+  catalog?: string;
+  filters?: Filter[];
+  sort?: Sort;
+  maxResults?: number;
+  nextToken?: string;
+}
+export interface SearchAgreementsOutput {
+  agreementViewSummaries?: AgreementViewSummary[];
+  nextToken?: string;
+}

package/dist-types/ts3.4/pagination/GetAgreementTermsPaginator.d.ts

@@ -0,0 +1,11 @@
+import { Paginator } from "@smithy/types";
+import {
+  GetAgreementTermsCommandInput,
+  GetAgreementTermsCommandOutput,
+} from "../commands/GetAgreementTermsCommand";
+import { MarketplaceAgreementPaginationConfiguration } from "./Interfaces";
+export declare function paginateGetAgreementTerms(
+  config: MarketplaceAgreementPaginationConfiguration,
+  input: GetAgreementTermsCommandInput,
+  ...additionalArguments: any
+): Paginator<GetAgreementTermsCommandOutput>;

package/dist-types/ts3.4/pagination/Interfaces.d.ts

@@ -0,0 +1,6 @@
+import { PaginationConfiguration } from "@smithy/types";
+import { MarketplaceAgreementClient } from "../MarketplaceAgreementClient";
+export interface MarketplaceAgreementPaginationConfiguration
+  extends PaginationConfiguration {
+  client: MarketplaceAgreementClient;
+}

package/dist-types/ts3.4/pagination/SearchAgreementsPaginator.d.ts

@@ -0,0 +1,11 @@
+import { Paginator } from "@smithy/types";
+import {
+  SearchAgreementsCommandInput,
+  SearchAgreementsCommandOutput,
+} from "../commands/SearchAgreementsCommand";
+import { MarketplaceAgreementPaginationConfiguration } from "./Interfaces";
+export declare function paginateSearchAgreements(
+  config: MarketplaceAgreementPaginationConfiguration,
+  input: SearchAgreementsCommandInput,
+  ...additionalArguments: any
+): Paginator<SearchAgreementsCommandOutput>;

package/dist-types/ts3.4/pagination/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./GetAgreementTermsPaginator";
+export * from "./Interfaces";
+export * from "./SearchAgreementsPaginator";

package/dist-types/ts3.4/protocols/Aws_json1_0.d.ts

@@ -0,0 +1,41 @@
+import {
+  HttpRequest as __HttpRequest,
+  HttpResponse as __HttpResponse,
+} from "@smithy/protocol-http";
+import { SerdeContext as __SerdeContext } from "@smithy/types";
+import {
+  DescribeAgreementCommandInput,
+  DescribeAgreementCommandOutput,
+} from "../commands/DescribeAgreementCommand";
+import {
+  GetAgreementTermsCommandInput,
+  GetAgreementTermsCommandOutput,
+} from "../commands/GetAgreementTermsCommand";
+import {
+  SearchAgreementsCommandInput,
+  SearchAgreementsCommandOutput,
+} from "../commands/SearchAgreementsCommand";
+export declare const se_DescribeAgreementCommand: (
+  input: DescribeAgreementCommandInput,
+  context: __SerdeContext
+) => Promise<__HttpRequest>;
+export declare const se_GetAgreementTermsCommand: (
+  input: GetAgreementTermsCommandInput,
+  context: __SerdeContext
+) => Promise<__HttpRequest>;
+export declare const se_SearchAgreementsCommand: (
+  input: SearchAgreementsCommandInput,
+  context: __SerdeContext
+) => Promise<__HttpRequest>;
+export declare const de_DescribeAgreementCommand: (
+  output: __HttpResponse,
+  context: __SerdeContext
+) => Promise<DescribeAgreementCommandOutput>;
+export declare const de_GetAgreementTermsCommand: (
+  output: __HttpResponse,
+  context: __SerdeContext
+) => Promise<GetAgreementTermsCommandOutput>;
+export declare const de_SearchAgreementsCommand: (
+  output: __HttpResponse,
+  context: __SerdeContext
+) => Promise<SearchAgreementsCommandOutput>;

package/dist-types/ts3.4/runtimeConfig.browser.d.ts

@@ -0,0 +1,99 @@
+import { FetchHttpHandler as RequestHandler } from "@smithy/fetch-http-handler";
+import { MarketplaceAgreementClientConfig } from "./MarketplaceAgreementClient";
+export declare const getRuntimeConfig: (
+  config: MarketplaceAgreementClientConfig
+) => {
+  runtime: string;
+  defaultsMode: import("@smithy/types").Provider<
+    import("@smithy/smithy-client").ResolvedDefaultsMode
+  >;
+  bodyLengthChecker: import("@smithy/types").BodyLengthCalculator;
+  credentialDefaultProvider: (
+    input: any
+  ) => import("@smithy/types").Provider<import("@aws-sdk/types").Credentials>;
+  defaultUserAgentProvider: import("@smithy/types").Provider<
+    import("@smithy/types").UserAgent
+  >;
+  maxAttempts: number | import("@smithy/types").Provider<number>;
+  region: string | import("@smithy/types").Provider<any>;
+  requestHandler:
+    | (import("@smithy/types").RequestHandler<
+        any,
+        any,
+        import("@smithy/types").HttpHandlerOptions
+      > &
+        import("@smithy/types").RequestHandler<
+          import("@smithy/protocol-http").HttpRequest,
+          import("@smithy/protocol-http").HttpResponse,
+          import("@smithy/types").HttpHandlerOptions
+        > & {
+          updateHttpClientConfig(key: never, value: never): void;
+          httpHandlerConfigs(): {};
+        })
+    | RequestHandler;
+  retryMode: string | import("@smithy/types").Provider<string>;
+  sha256: import("@smithy/types").HashConstructor;
+  streamCollector: import("@smithy/types").StreamCollector;
+  useDualstackEndpoint: boolean | import("@smithy/types").Provider<boolean>;
+  useFipsEndpoint: boolean | import("@smithy/types").Provider<boolean>;
+  apiVersion: string;
+  urlParser: import("@smithy/types").UrlParser;
+  base64Decoder: import("@smithy/types").Decoder;
+  base64Encoder: import("@smithy/types").Encoder;
+  utf8Decoder: import("@smithy/types").Decoder;
+  utf8Encoder: import("@smithy/types").Encoder;
+  disableHostPrefix: boolean;
+  serviceId: string;
+  logger: import("@smithy/types").Logger;
+  extensions: import("./runtimeExtensions").RuntimeExtension[];
+  endpoint?:
+    | ((
+        | string
+        | import("@smithy/types").Endpoint
+        | import("@smithy/types").Provider<import("@smithy/types").Endpoint>
+        | import("@smithy/types").EndpointV2
+        | import("@smithy/types").Provider<import("@smithy/types").EndpointV2>
+      ) &
+        (
+          | string
+          | import("@smithy/types").Provider<string>
+          | import("@smithy/types").Endpoint
+          | import("@smithy/types").Provider<import("@smithy/types").Endpoint>
+          | import("@smithy/types").EndpointV2
+          | import("@smithy/types").Provider<import("@smithy/types").EndpointV2>
+        ))
+    | undefined;
+  endpointProvider: (
+    endpointParams: import("./endpoint/EndpointParameters").EndpointParameters,
+    context?: {
+      logger?: import("@smithy/types").Logger | undefined;
+    }
+  ) => import("@smithy/types").EndpointV2;
+  tls?: boolean | undefined;
+  retryStrategy?:
+    | import("@smithy/types").RetryStrategy
+    | import("@smithy/types").RetryStrategyV2
+    | undefined;
+  credentials?:
+    | import("@smithy/types").AwsCredentialIdentity
+    | import("@smithy/types").Provider<
+        import("@smithy/types").AwsCredentialIdentity
+      >
+    | undefined;
+  signer?:
+    | import("@smithy/types").RequestSigner
+    | ((
+        authScheme?: import("@smithy/types").AuthScheme | undefined
+      ) => Promise<import("@smithy/types").RequestSigner>)
+    | undefined;
+  signingEscapePath?: boolean | undefined;
+  systemClockOffset?: number | undefined;
+  signingRegion?: string | undefined;
+  signerConstructor?:
+    | (new (
+        options: import("@smithy/signature-v4").SignatureV4Init &
+          import("@smithy/signature-v4").SignatureV4CryptoInit
+      ) => import("@smithy/types").RequestSigner)
+    | undefined;
+  customUserAgent?: string | import("@smithy/types").UserAgent | undefined;
+};