export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
    AWSDate: {
        input: unknown;
        output: unknown;
    };
    AWSDateTime: {
        input: unknown;
        output: unknown;
    };
    AWSEmail: {
        input: unknown;
        output: unknown;
    };
    AWSIPAddress: {
        input: unknown;
        output: unknown;
    };
    AWSJSON: {
        input: unknown;
        output: unknown;
    };
    AWSPhone: {
        input: unknown;
        output: unknown;
    };
    AWSTime: {
        input: unknown;
        output: unknown;
    };
    AWSTimestamp: {
        input: unknown;
        output: unknown;
    };
    AWSURL: {
        input: unknown;
        output: unknown;
    };
};
export type AddressInput = {
    addressLine1: Scalars['String']['input'];
    addressLine2?: InputMaybe<Scalars['String']['input']>;
    city: Scalars['String']['input'];
    country: Scalars['String']['input'];
    postalCode: Scalars['String']['input'];
    state: Scalars['String']['input'];
};
export type BankAccountFundingSource = CommonFundingSource & CommonObject & {
    __typename?: 'BankAccountFundingSource';
    bankAccountType: BankAccountType;
    createdAtEpochMs: Scalars['Float']['output'];
    currency: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    institutionLogo?: Maybe<SealedAttribute>;
    institutionName: SealedAttribute;
    last4: Scalars['String']['output'];
    owner: Scalars['ID']['output'];
    state: FundingSourceState;
    transactionVelocity?: Maybe<TransactionVelocity>;
    unfundedAmount?: Maybe<CurrencyAmount>;
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export declare enum BankAccountType {
    Checking = "CHECKING",
    Other = "OTHER",
    Savings = "SAVINGS"
}
export type CardCancelRequest = {
    id: Scalars['ID']['input'];
    keyId?: InputMaybe<Scalars['String']['input']>;
};
export type CardFilterInput = {
    and?: InputMaybe<Array<CardFilterInput>>;
    id?: InputMaybe<IdFilterInput>;
    keyId?: InputMaybe<IdFilterInput>;
    not?: InputMaybe<CardFilterInput>;
    or?: InputMaybe<Array<CardFilterInput>>;
    state?: InputMaybe<IdFilterInput>;
};
export type CardProvisionRequest = {
    alias?: InputMaybe<Scalars['String']['input']>;
    billingAddress?: InputMaybe<AddressInput>;
    cardHolder: Scalars['String']['input'];
    clientRefId: Scalars['String']['input'];
    currency: Scalars['String']['input'];
    fundingSourceId: Scalars['ID']['input'];
    keyRingId: Scalars['ID']['input'];
    metadata?: InputMaybe<SealedAttributeInput>;
    ownerProofs: Array<Scalars['ID']['input']>;
};
export declare enum CardState {
    Closed = "CLOSED",
    Failed = "FAILED",
    Issued = "ISSUED",
    Suspended = "SUSPENDED"
}
export declare enum CardType {
    Credit = "CREDIT",
    Debit = "DEBIT",
    Other = "OTHER",
    Prepaid = "PREPAID"
}
export type CardUpdateRequest = {
    alias?: InputMaybe<Scalars['String']['input']>;
    billingAddress?: InputMaybe<AddressInput>;
    cardHolder?: InputMaybe<Scalars['String']['input']>;
    expectedVersion?: InputMaybe<Scalars['Int']['input']>;
    id: Scalars['ID']['input'];
    keyId?: InputMaybe<Scalars['String']['input']>;
    metadata?: InputMaybe<SealedAttributeInput>;
};
export type CommonFundingSource = {
    createdAtEpochMs: Scalars['Float']['output'];
    currency: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    owner: Scalars['ID']['output'];
    state: FundingSourceState;
    transactionVelocity?: Maybe<TransactionVelocity>;
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export type CommonObject = {
    createdAtEpochMs: Scalars['Float']['output'];
    id: Scalars['ID']['output'];
    owner: Scalars['ID']['output'];
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export type CompleteFundingSourceRequest = {
    completionData: Scalars['ID']['input'];
    id: Scalars['ID']['input'];
    updateCardFundingSource?: InputMaybe<Scalars['Boolean']['input']>;
};
export type CreatePublicKeyInput = {
    algorithm: Scalars['String']['input'];
    keyFormat?: InputMaybe<KeyFormat>;
    keyId: Scalars['String']['input'];
    keyRingId: Scalars['String']['input'];
    publicKey: Scalars['String']['input'];
};
export type CreditCardFundingSource = CommonFundingSource & CommonObject & {
    __typename?: 'CreditCardFundingSource';
    cardType: CardType;
    createdAtEpochMs: Scalars['Float']['output'];
    currency: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    last4: Scalars['String']['output'];
    network: CreditCardNetwork;
    owner: Scalars['ID']['output'];
    state: FundingSourceState;
    transactionVelocity?: Maybe<TransactionVelocity>;
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export declare enum CreditCardNetwork {
    Amex = "AMEX",
    Diners = "DINERS",
    Discover = "DISCOVER",
    Jcb = "JCB",
    Mastercard = "MASTERCARD",
    Other = "OTHER",
    Unionpay = "UNIONPAY",
    Visa = "VISA"
}
export type CurrencyAmount = {
    __typename?: 'CurrencyAmount';
    amount: Scalars['Int']['output'];
    currency: Scalars['String']['output'];
};
export type CurrencyVelocity = {
    __typename?: 'CurrencyVelocity';
    currency: Scalars['String']['output'];
    velocity: Array<Scalars['String']['output']>;
};
export type DateRangeInput = {
    endDateEpochMs: Scalars['Float']['input'];
    startDateEpochMs: Scalars['Float']['input'];
};
export type DisableUser = {
    __typename?: 'DisableUser';
    success: Scalars['Boolean']['output'];
};
export type DisableUserInput = {
    username: Scalars['String']['input'];
};
export type EnableUser = {
    __typename?: 'EnableUser';
    success: Scalars['Boolean']['output'];
};
export type EnableUserInput = {
    username: Scalars['String']['input'];
};
export type FundingSource = BankAccountFundingSource | CreditCardFundingSource;
export type FundingSourceClientConfiguration = {
    __typename?: 'FundingSourceClientConfiguration';
    data: Scalars['ID']['output'];
};
export type FundingSourceConnection = {
    __typename?: 'FundingSourceConnection';
    items: Array<FundingSource>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type FundingSourceFilterInput = {
    and?: InputMaybe<Array<FundingSourceFilterInput>>;
    id?: InputMaybe<IdFilterInput>;
    not?: InputMaybe<FundingSourceFilterInput>;
    or?: InputMaybe<Array<FundingSourceFilterInput>>;
    state?: InputMaybe<FundingSourceStateFilterInput>;
};
export declare enum FundingSourceState {
    Active = "ACTIVE",
    Inactive = "INACTIVE"
}
export type FundingSourceStateFilterInput = {
    eq?: InputMaybe<FundingSourceState>;
    ne?: InputMaybe<FundingSourceState>;
};
export type FundingSourceSupportDetail = {
    __typename?: 'FundingSourceSupportDetail';
    cardType: CardType;
};
export type FundingSourceSupportInfo = {
    __typename?: 'FundingSourceSupportInfo';
    detail: Array<FundingSourceSupportDetail>;
    fundingSourceType: Scalars['String']['output'];
    network: Scalars['String']['output'];
    providerType: Scalars['String']['output'];
};
export declare enum FundingSourceType {
    CreditCard = "CREDIT_CARD"
}
export type IdFilterInput = {
    beginsWith?: InputMaybe<Scalars['ID']['input']>;
    between?: InputMaybe<Array<InputMaybe<Scalars['ID']['input']>>>;
    contains?: InputMaybe<Scalars['ID']['input']>;
    eq?: InputMaybe<Scalars['ID']['input']>;
    ge?: InputMaybe<Scalars['ID']['input']>;
    gt?: InputMaybe<Scalars['ID']['input']>;
    le?: InputMaybe<Scalars['ID']['input']>;
    lt?: InputMaybe<Scalars['ID']['input']>;
    ne?: InputMaybe<Scalars['ID']['input']>;
    notContains?: InputMaybe<Scalars['ID']['input']>;
};
export type IdInput = {
    id: Scalars['ID']['input'];
};
export declare enum KeyFormat {
    RsaPublicKey = "RSA_PUBLIC_KEY",
    Spki = "SPKI"
}
export type Mutation = {
    __typename?: 'Mutation';
    cancelCard: SealedCard;
    cancelFundingSource: FundingSource;
    cancelProvisionalFundingSource: ProvisionalFundingSource;
    cardProvision: ProvisionalCard;
    completeFundingSource: FundingSource;
    createPublicKeyForVirtualCards: PublicKey;
    disableUser: DisableUser;
    enableUser: EnableUser;
    setupFundingSource: ProvisionalFundingSource;
    updateCard: SealedCard;
};
export type MutationCancelCardArgs = {
    input: CardCancelRequest;
};
export type MutationCancelFundingSourceArgs = {
    input: IdInput;
};
export type MutationCancelProvisionalFundingSourceArgs = {
    input: IdInput;
};
export type MutationCardProvisionArgs = {
    input: CardProvisionRequest;
};
export type MutationCompleteFundingSourceArgs = {
    input: CompleteFundingSourceRequest;
};
export type MutationCreatePublicKeyForVirtualCardsArgs = {
    input: CreatePublicKeyInput;
};
export type MutationDisableUserArgs = {
    input: DisableUserInput;
};
export type MutationEnableUserArgs = {
    input: EnableUserInput;
};
export type MutationSetupFundingSourceArgs = {
    input: SetupFundingSourceRequest;
};
export type MutationUpdateCardArgs = {
    input?: InputMaybe<CardUpdateRequest>;
};
export type Owner = {
    __typename?: 'Owner';
    id: Scalars['String']['output'];
    issuer: Scalars['String']['output'];
};
export type PaginatedPublicKey = {
    __typename?: 'PaginatedPublicKey';
    items: Array<PublicKey>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ProvisionalCard = {
    __typename?: 'ProvisionalCard';
    card?: Maybe<Array<SealedCard>>;
    clientRefId: Scalars['String']['output'];
    createdAtEpochMs: Scalars['Float']['output'];
    id: Scalars['ID']['output'];
    owner: Scalars['ID']['output'];
    provisioningState: ProvisioningState;
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export type ProvisionalCardConnection = {
    __typename?: 'ProvisionalCardConnection';
    items: Array<ProvisionalCard>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ProvisionalFundingSource = CommonObject & {
    __typename?: 'ProvisionalFundingSource';
    createdAtEpochMs: Scalars['Float']['output'];
    id: Scalars['ID']['output'];
    last4?: Maybe<Scalars['String']['output']>;
    owner: Scalars['ID']['output'];
    provisioningData: Scalars['ID']['output'];
    state: ProvisionalFundingSourceState;
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export type ProvisionalFundingSourceConnection = {
    __typename?: 'ProvisionalFundingSourceConnection';
    items: Array<ProvisionalFundingSource>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type ProvisionalFundingSourceFilterInput = {
    and?: InputMaybe<Array<ProvisionalFundingSourceFilterInput>>;
    id?: InputMaybe<IdFilterInput>;
    not?: InputMaybe<ProvisionalFundingSourceFilterInput>;
    or?: InputMaybe<Array<ProvisionalFundingSourceFilterInput>>;
    state?: InputMaybe<ProvisionalFundingSourceStateFilterInput>;
};
export declare enum ProvisionalFundingSourceState {
    Completed = "COMPLETED",
    Failed = "FAILED",
    Pending = "PENDING",
    Provisioning = "PROVISIONING"
}
export type ProvisionalFundingSourceStateFilterInput = {
    eq?: InputMaybe<ProvisionalFundingSourceState>;
    ne?: InputMaybe<ProvisionalFundingSourceState>;
};
export declare enum ProvisioningState {
    Completed = "COMPLETED",
    Failed = "FAILED",
    Provisioning = "PROVISIONING"
}
export type PublicKey = {
    __typename?: 'PublicKey';
    algorithm: Scalars['String']['output'];
    createdAtEpochMs: Scalars['Float']['output'];
    id: Scalars['ID']['output'];
    keyFormat?: Maybe<KeyFormat>;
    keyId: Scalars['String']['output'];
    keyRingId: Scalars['String']['output'];
    owner: Scalars['ID']['output'];
    publicKey: Scalars['String']['output'];
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export type Query = {
    __typename?: 'Query';
    getCard?: Maybe<SealedCard>;
    getFundingSource?: Maybe<FundingSource>;
    getFundingSourceClientConfiguration: FundingSourceClientConfiguration;
    getKeyRingForVirtualCards: PaginatedPublicKey;
    getProvisionalCard?: Maybe<ProvisionalCard>;
    getPublicKeyForVirtualCards?: Maybe<PublicKey>;
    getPublicKeysForVirtualCards: PaginatedPublicKey;
    getTransaction?: Maybe<SealedTransaction>;
    getVirtualCardsConfig: VirtualCardsConfig;
    listCards: SealedCardConnection;
    listFundingSources: FundingSourceConnection;
    listProvisionalCards: ProvisionalCardConnection;
    listProvisionalFundingSources: ProvisionalFundingSourceConnection;
    listTransactions2: SealedTransactionConnection;
    listTransactionsByCardId2: SealedTransactionConnection;
    listTransactionsByCardIdAndType: SealedTransactionConnection;
};
export type QueryGetCardArgs = {
    id: Scalars['ID']['input'];
    keyId?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGetFundingSourceArgs = {
    id: Scalars['ID']['input'];
};
export type QueryGetKeyRingForVirtualCardsArgs = {
    keyFormats?: InputMaybe<Array<KeyFormat>>;
    keyRingId: Scalars['String']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGetProvisionalCardArgs = {
    id: Scalars['ID']['input'];
};
export type QueryGetPublicKeyForVirtualCardsArgs = {
    keyFormats?: InputMaybe<Array<KeyFormat>>;
    keyId: Scalars['String']['input'];
};
export type QueryGetPublicKeysForVirtualCardsArgs = {
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGetTransactionArgs = {
    id: Scalars['ID']['input'];
    keyId?: InputMaybe<Scalars['String']['input']>;
};
export type QueryListCardsArgs = {
    filter?: InputMaybe<CardFilterInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
    sortOrder?: InputMaybe<SortOrder>;
};
export type QueryListFundingSourcesArgs = {
    filter?: InputMaybe<FundingSourceFilterInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
    sortOrder?: InputMaybe<SortOrder>;
};
export type QueryListProvisionalCardsArgs = {
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
};
export type QueryListProvisionalFundingSourcesArgs = {
    filter?: InputMaybe<ProvisionalFundingSourceFilterInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
    sortOrder?: InputMaybe<SortOrder>;
};
export type QueryListTransactions2Args = {
    dateRange?: InputMaybe<DateRangeInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
    sortOrder?: InputMaybe<SortOrder>;
};
export type QueryListTransactionsByCardId2Args = {
    cardId: Scalars['ID']['input'];
    dateRange?: InputMaybe<DateRangeInput>;
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
    sortOrder?: InputMaybe<SortOrder>;
};
export type QueryListTransactionsByCardIdAndTypeArgs = {
    cardId: Scalars['ID']['input'];
    limit?: InputMaybe<Scalars['Int']['input']>;
    nextToken?: InputMaybe<Scalars['String']['input']>;
    transactionType: TransactionType;
};
export type SealedAddressAttribute = {
    __typename?: 'SealedAddressAttribute';
    addressLine1: Scalars['String']['output'];
    addressLine2?: Maybe<Scalars['String']['output']>;
    city: Scalars['String']['output'];
    country: Scalars['String']['output'];
    postalCode: Scalars['String']['output'];
    state: Scalars['String']['output'];
};
export type SealedAttribute = {
    __typename?: 'SealedAttribute';
    algorithm: Scalars['String']['output'];
    base64EncodedSealedData: Scalars['String']['output'];
    keyId: Scalars['String']['output'];
    plainTextType: Scalars['String']['output'];
};
export type SealedAttributeInput = {
    algorithm: Scalars['String']['input'];
    base64EncodedSealedData: Scalars['String']['input'];
    keyId: Scalars['String']['input'];
    plainTextType: Scalars['String']['input'];
};
export type SealedCard = {
    __typename?: 'SealedCard';
    activeToEpochMs: Scalars['Float']['output'];
    algorithm: Scalars['String']['output'];
    alias?: Maybe<Scalars['String']['output']>;
    billingAddress?: Maybe<SealedAddressAttribute>;
    cancelledAtEpochMs?: Maybe<Scalars['Float']['output']>;
    cardHolder: Scalars['String']['output'];
    createdAtEpochMs: Scalars['Float']['output'];
    csc: Scalars['String']['output'];
    currency: Scalars['String']['output'];
    expiry: SealedExpiryAttribute;
    fundingSourceId: Scalars['ID']['output'];
    id: Scalars['ID']['output'];
    keyId: Scalars['String']['output'];
    keyRingId: Scalars['ID']['output'];
    last4: Scalars['String']['output'];
    lastTransaction?: Maybe<SealedTransaction>;
    metadata?: Maybe<SealedAttribute>;
    owner: Scalars['ID']['output'];
    owners: Array<Owner>;
    pan: Scalars['String']['output'];
    state: CardState;
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export type SealedCardConnection = {
    __typename?: 'SealedCardConnection';
    items: Array<SealedCard>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type SealedCurrencyAmountAttribute = {
    __typename?: 'SealedCurrencyAmountAttribute';
    amount: Scalars['String']['output'];
    currency: Scalars['String']['output'];
};
export type SealedExpiryAttribute = {
    __typename?: 'SealedExpiryAttribute';
    mm: Scalars['String']['output'];
    yyyy: Scalars['String']['output'];
};
export type SealedMarkupAttribute = {
    __typename?: 'SealedMarkupAttribute';
    flat: Scalars['String']['output'];
    minCharge?: Maybe<Scalars['String']['output']>;
    percent: Scalars['String']['output'];
};
export type SealedTransaction = {
    __typename?: 'SealedTransaction';
    algorithm: Scalars['String']['output'];
    billedAmount: SealedCurrencyAmountAttribute;
    cardId: Scalars['ID']['output'];
    createdAtEpochMs: Scalars['Float']['output'];
    declineReason?: Maybe<Scalars['String']['output']>;
    description: Scalars['String']['output'];
    detail?: Maybe<Array<SealedTransactionDetailChargeAttribute>>;
    id: Scalars['ID']['output'];
    keyId: Scalars['String']['output'];
    owner: Scalars['ID']['output'];
    sequenceId: Scalars['ID']['output'];
    settledAtEpochMs?: Maybe<Scalars['String']['output']>;
    sortDateEpochMs: Scalars['Float']['output'];
    transactedAmount: SealedCurrencyAmountAttribute;
    transactedAtEpochMs: Scalars['String']['output'];
    type: TransactionType;
    updatedAtEpochMs: Scalars['Float']['output'];
    version: Scalars['Int']['output'];
};
export type SealedTransactionConnection = {
    __typename?: 'SealedTransactionConnection';
    items: Array<SealedTransaction>;
    nextToken?: Maybe<Scalars['String']['output']>;
};
export type SealedTransactionDetailChargeAttribute = {
    __typename?: 'SealedTransactionDetailChargeAttribute';
    continuationOfExistingCharge?: Maybe<Scalars['Boolean']['output']>;
    description: Scalars['String']['output'];
    fundingSourceAmount: SealedCurrencyAmountAttribute;
    fundingSourceId: Scalars['ID']['output'];
    markup: SealedMarkupAttribute;
    markupAmount: SealedCurrencyAmountAttribute;
    settledAtEpochMs?: Maybe<Scalars['String']['output']>;
    state?: Maybe<Scalars['String']['output']>;
    transactedAtEpochMs?: Maybe<Scalars['String']['output']>;
    virtualCardAmount: SealedCurrencyAmountAttribute;
};
export type SetupFundingSourceRequest = {
    currency: Scalars['String']['input'];
    language?: InputMaybe<Scalars['String']['input']>;
    setupData?: InputMaybe<Scalars['ID']['input']>;
    supportedProviders?: InputMaybe<Array<Scalars['String']['input']>>;
    type: FundingSourceType;
};
export declare enum SortOrder {
    Asc = "ASC",
    Desc = "DESC"
}
export type Subscription = {
    __typename?: 'Subscription';
    onFundingSourceUpdate?: Maybe<FundingSource>;
};
export type SubscriptionOnFundingSourceUpdateArgs = {
    owner: Scalars['ID']['input'];
};
export declare enum TransactionType {
    Complete = "COMPLETE",
    Decline = "DECLINE",
    Pending = "PENDING",
    Refund = "REFUND"
}
export type TransactionVelocity = {
    __typename?: 'TransactionVelocity';
    maximum?: Maybe<Scalars['Int']['output']>;
    velocity?: Maybe<Array<Scalars['String']['output']>>;
};
export type VirtualCardApplicationsConfiguration = {
    __typename?: 'VirtualCardApplicationsConfiguration';
    data: Scalars['ID']['output'];
};
export type VirtualCardPricingPolicy = {
    __typename?: 'VirtualCardPricingPolicy';
    data: Scalars['ID']['output'];
};
export type VirtualCardsConfig = {
    __typename?: 'VirtualCardsConfig';
    bankAccountFundingSourceCreationEnabled?: Maybe<Scalars['Boolean']['output']>;
    bankAccountFundingSourceExpendableEnabled: Scalars['Boolean']['output'];
    clientApplicationsConfiguration?: Maybe<VirtualCardApplicationsConfiguration>;
    fundingSourceClientConfiguration?: Maybe<FundingSourceClientConfiguration>;
    fundingSourceSupportInfo: Array<FundingSourceSupportInfo>;
    maxCardCreationVelocity: Array<Scalars['String']['output']>;
    maxFundingSourceFailureVelocity: Array<Scalars['String']['output']>;
    maxFundingSourcePendingVelocity?: Maybe<Array<Scalars['String']['output']>>;
    maxFundingSourceVelocity: Array<Scalars['String']['output']>;
    maxTransactionAmount: Array<CurrencyAmount>;
    maxTransactionVelocity: Array<CurrencyVelocity>;
    pricingPolicy?: Maybe<VirtualCardPricingPolicy>;
    virtualCardCurrencies: Array<Scalars['String']['output']>;
};