.nav-dropdown-content {
  width: var(--radix-dropdown-menu-trigger-width);
}

.nav-dropdown-item[data-dropdown-item="CDP API v2"]
  > .nav-dropdown-item-text-container
  > .nav-dropdown-item-title::after {
  content: "Beta" !important;
  background-color: #004cec1a;
  color: #0052ff;
  font-size: 0.75rem;
  font-weight: 600;
  padding: 2px 8px;
  border-radius: 12px;
  margin-left: 8px;
}


@font-face {
  font-family: "Coinbase Text Medium";
  src: url("https://mintlify-assets.b-cdn.net/fonts/coinbase/Coinbase_Text-Medium-web-1.32.woff2")
    format("woff2");
  font-weight: 500;
  font-style: normal;
}

.dark li[id="topbar-cta-button"] > a > span {
  background-color: #578bf9 !important;
}

.dark li[id="topbar-cta-button"] > a > div > svg {
  color: #101521 !important;
}

.dark li[id="topbar-cta-button"] > a > div > span {
  color: #101521 !important;
}

div[data-callout-type="info"] {
  background-color: #f5f8fe !important;
  color: #0052fe !important;
  border-color: #ccdcfe !important;
}

div[data-callout-type="info"] > div > svg {
  color: white !important;
}

div[data-callout-type="info"] > div > svg > path {
  fill: #0052fe !important;
}

.dark div[data-callout-type="info"] {
  background-color: #001133 !important;
  color: #578bf9 !important;
  border-color: #2c406c !important;
}

.dark div[data-callout-type="info"] > div > svg > path {
  fill: #578bf9 !important;
}

div[data-callout-type="note"] {
  background-color: rgba(250, 250, 250, 0.5) !important;
  color: #578bf9 !important;
  border-color: rgba(113, 113, 122, 0.2) !important;
}

div[data-callout-type="note"] > div > svg {
  color: white !important;
}

div[data-callout-type="note"] > div > ul > li {
  color: #18181b !important;
}

.dark div[data-callout-type="note"] > div > ul > li {
  color: #e4e4e7 !important;
}

div[data-callout-type="note"] > div > svg > path {
  fill: #0052fe !important;
}

.dark div[data-callout-type="note"] {
  background-color: rgba(113, 113, 122, 0.1) !important;
  color: #578bf9 !important;
  border-color: rgba(113, 113, 122, 0.3) !important;
}

.dark div[data-callout-type="note"] > div > svg > path {
  fill: #578bf9 !important;
}

.dark div[data-callout-type="note"] > div > p {
  color: #e4e4e7 !important;
}
div[data-callout-type="note"] > div > p {
  color: #18181b !important;
}

#\/ {
  display: none;
}

h1,
h2,
span {
  letter-spacing: 0.02em !important;
}

/* Nav section header styles */
.nav-section-header {
  font-size: 0.7rem !important;
  font-weight: 600 !important;
  text-transform: uppercase !important;
  letter-spacing: 0.05em !important;
  color: #6b7280 !important;
  padding: 12px 8px 4px 8px !important;
  margin-bottom: 4px !important;
}

.nav-section-header.with-divider {
  border-top: 1px solid #e5e7eb !important;
  margin-top: 8px !important;
}

.dark .nav-section-header {
  color: #9ca3af !important;
}

.dark .nav-section-header.with-divider {
  border-top-color: rgba(255, 255, 255, 0.1) !important;
}

.version-option:hover {
  background-color: #f1f5f9 !important;
}

.dark .version-option:hover {
  background-color: #4b5563 !important;
}

/* Version-specific visibility rules to prevent flash on page load */
/* Initially hide v1 Wallet API content by default */
li[data-group-tag="v1"][data-title="Wallet API"] {
  display: none !important;
}

/* Show v1 content only when the URL contains v1 */
body.url-contains-v1 li[data-group-tag="v1"][data-title="Wallet API"] {
  display: block !important;
}

/* Ensure v2 content is visible by default */
li[data-group-tag="v2"][data-title="Wallet API"] {
  display: block !important;
}

/* Hide v2 content when v1 is active */
body.url-contains-v1 li[data-group-tag="v2"][data-title="Wallet API"] {
  display: none !important;
}

.nav-tag-pill-text[data-nav-tag="v1"] {
  cursor: pointer !important;
  user-select: none !important;
  display: flex !important;
  align-items: center !important;
  padding: 2px 8px !important;
}

.nav-tag-pill-text[data-nav-tag="v2"] {
  cursor: pointer !important;
  user-select: none !important;
  display: flex !important;
  align-items: center !important;
  padding: 2px 8px !important;
}

/* Add dropdown arrow using ::after pseudo-element */
.nav-tag-pill-text[data-nav-tag="v1"]::after,
.nav-tag-pill-text[data-nav-tag="v2"]::after {
  color: #004cec !important;
  content: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 24 24' fill='none' stroke='%23004cec' stroke-width='3' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='m6 9 6 6 6-6'/%3E%3C/svg%3E");
  margin-left: 4px;
  padding-top: 4px;
  opacity: 0.6;
}

#footer > div {
  padding-top: 5rem !important;
  padding-bottom: 4rem !important;
}

.tab-container > ul {
  margin-bottom: 1rem !important;
}

.code-block {
  margin-top: 0px !important;
}

button[data-component-part="tab-button"] {
  font-size: 1rem !important;
}

@media (min-width: 1024px) {
  div[id="content-container"] {
    padding-left: 4rem !important;
    padding-right: 1rem !important;
  }
}

#sidebar-title {
  font-family: "Coinbase Text Medium", sans-serif !important;
  color: #111827 !important;
  font-size: 0.8rem !important;
  font-weight: 500 !important;
}

.dark #sidebar-title {
  font-family: "Coinbase Text Medium", sans-serif !important;
  color: #e5e7eb !important;
  font-size: 0.8rem !important;
  font-weight: 500 !important;
}


// Get the target element - specifically the inner div with the disclaimer text
const targetElement = document.querySelector(
  "#chat-assistant-sheet > div > div.chat-assistant-sheet-content > div > div",
);

if (targetElement) {
  // Clear the existing content
  targetElement.textContent = "";

  // Create the disclaimer text
  const disclaimerText = document.createTextNode(
    "This is an AI generated summary and may contain mistakes. It is not intended to give advice, including legal, financial or tax advice. It does not have access to your account information. By using this AI-assistant, you agree to the ",
  );

  // Create the link element
  const tosLink = document.createElement("a");
  tosLink.href =
    "https://www.coinbase.com/legal/developer-platform/terms-of-service";
  tosLink.textContent = "CDP ToS";
  tosLink.target = "_blank";
  tosLink.rel = "noopener noreferrer";
  tosLink.style.borderBottom = "1px solid rgb(var(--primary))";

  // Add the period after the link
  const period = document.createTextNode(".");

  // Append all elements to the disclaimer div
  targetElement.appendChild(disclaimerText);
  targetElement.appendChild(tosLink);
  targetElement.appendChild(period);
}


const isProduction = window.location.hostname === "docs.cdp.coinbase.com";

const DEVELOPMENT_ENVIRONMENT_ID = "5ZyvBnXc4D7y";
const PRODUCTION_ENVIRONMENT_ID = "zxxktKL2Pd1v";

const ENVIRONMENT_ID = isProduction
  ? PRODUCTION_ENVIRONMENT_ID
  : DEVELOPMENT_ENVIRONMENT_ID;

// code below comes from https://docs.sprig.com/docs/web-javascript#install-with-html-recommended
(function (l, e, a, p) {
  if (window.Sprig) return;
  window.Sprig = function () {
    S._queue.push(arguments);
  };
  var S = window.Sprig;
  S.appId = a;
  S._queue = [];
  window.UserLeap = S;
  a = l.createElement("script");
  a.async = 1;
  a.src = e + "?id=" + S.appId;
  p = l.getElementsByTagName("script")[0];
  p.parentNode.insertBefore(a, p);
})(document, "https://cdn.sprig.com/shim.js", ENVIRONMENT_ID);


const { execSync } = require("child_process");
const path = require("path");

const specId = process.argv[2];

const openApiSpecs = [
  {
    id: "cdp-api-v2",
    name: "CDP API V2",
    url: "https://drla6sbl8l00t.cloudfront.net/openapi.yaml",
    path: path.join(__dirname, "../api-reference/v2/cdp-api-v2.yaml"),
  },
];

openApiSpecs.forEach((spec) => {
  if (spec.id !== specId) {
    return;
  }

  console.log(`Fetching latest ${spec.name} OpenAPI spec...`);
  // Add a random query parameter to prevent retrieval of a cached copy from CloudFront
  const urlWithNoCacheParam = `${spec.url}?nocache=${Date.now()}`;
  execSync(`curl ${urlWithNoCacheParam} -o ${spec.path}`, { stdio: "inherit" });
});


/**
 * Script to generate error documentation from OpenAPI specifications.
 *
 * The generated documentation is organized by HTTP status code and error type,
 * with up to MAX_EXAMPLES unique examples per error type.
 *
 * @usage node generate-openapi-error-page.js <spec-id>
 * @example node generate-openapi-error-page.js cdp-api-v2
 */

const path = require("path");
const fs = require("fs");
const yaml = require("js-yaml");

const baseUrl = "https://docs.cdp.coinbase.com/";
const specId = process.argv[2];

const openApiSpecs = [
  {
    id: "cdp-api-v2",
    name: "CDP API V2",
    specPath: path.join(__dirname, "../api-reference/v2/cdp-api-v2.yaml"),
    outputPath: path.join(__dirname, "../api-reference/v2/errors.mdx"),
  },
];

// Add validation for spec-id
if (!specId) {
  console.error("Error: No spec-id provided");
  console.error("Usage: node generate-openapi-error-page.js <spec-id>");
  process.exit(1);
}

const matchingSpec = openApiSpecs.find((spec) => spec.id === specId);
if (!matchingSpec) {
  console.error(`Error: Invalid spec-id "${specId}"`);
  console.error(
    "Available spec-ids:",
    openApiSpecs.map((s) => s.id).join(", "),
  );
  process.exit(1);
}

/**
 * Resolves a reference in the OpenAPI spec
 * @param {string} ref - The reference path (e.g. '#/components/responses/IdempotencyError')
 * @param {Object} spec - The full OpenAPI specification
 * @returns {Object} The resolved reference object
 */
function resolveRef(ref, spec) {
  const refParts = ref.replace("#/", "").split("/");
  return refParts.reduce((obj, key) => obj[key], spec);
}

/**
 * Gets the complete example by combining schema defaults with provided example
 * @param {Object} schema - The error schema definition
 * @param {Object} spec - The full OpenAPI specification for resolving refs
 * @param {Object} example - The provided example values
 * @returns {Object} Complete example with all schema fields
 */
function getCompleteExample(schema, spec, example = {}) {
  // If no example was provided, return null to skip this error
  if (Object.keys(example).length === 0) {
    return null;
  }

  // If schema is a reference, resolve it
  if (schema.$ref) {
    schema = resolveRef(schema.$ref, spec);
  }

  const complete = { ...example };

  // Add any missing required fields from schema
  if (schema.properties) {
    Object.entries(schema.properties).forEach(([field, prop]) => {
      if (!(field in complete)) {
        // If property is a reference, resolve it
        const resolvedProp = prop.$ref ? resolveRef(prop.$ref, spec) : prop;

        // Use example from property definition if available
        if (resolvedProp.example) {
          complete[field] = resolvedProp.example;
        } else if (resolvedProp.default) {
          complete[field] = resolvedProp.default;
        } else {
          // Use a descriptive placeholder for missing fields
          complete[field] = `<${field}>`;
        }
      }
    });

    // Add errorLink after all other properties are set
    const errorType = complete.errorType || "error-type";
    complete.errorLink = `${baseUrl}api-reference/v2/errors#${errorType}`;
  }

  return complete;
}

/**
 * Extracts error responses from an OpenAPI path object
 * @param {Object} pathObj - The OpenAPI path object containing response definitions
 * @param {Object} spec - The full OpenAPI specification for resolving refs
 * @returns {Array} Array of error objects with status, description and schema
 */
function extractErrorResponses(pathObj, spec) {
  const errors = [];

  // Look through each method (GET, POST, etc)
  Object.values(pathObj).forEach((method) => {
    if (!method.responses) return;

    // Look for error responses (4xx, 5xx)
    Object.entries(method.responses).forEach(([status, response]) => {
      if (!status.startsWith("4") && !status.startsWith("5")) return;

      // Resolve reference if present
      const resolvedResponse = response.$ref
        ? resolveRef(response.$ref, spec)
        : response;

      // Only process if there's a JSON schema
      if (resolvedResponse?.content?.["application/json"]?.schema) {
        const { schema } = resolvedResponse.content["application/json"];
        const resolvedSchema = schema.$ref
          ? resolveRef(schema.$ref, spec)
          : schema;

        // Handle both single example and multiple examples
        const examples =
          resolvedResponse.content["application/json"].examples ||
          (resolvedResponse.content["application/json"].example
            ? {
                default: {
                  value: resolvedResponse.content["application/json"].example,
                },
              }
            : {});

        // Process each example
        Object.entries(examples).forEach(([exampleName, exampleObj]) => {
          const completeExample = getCompleteExample(
            resolvedSchema,
            spec,
            exampleObj.value,
          );

          // Skip if no complete example could be generated
          if (!completeExample) return;

          errors.push({
            status,
            description: resolvedResponse.description,
            schema: resolvedSchema,
            example: completeExample,
            exampleName, // Include example name for multiple examples
          });
        });
      }
    });
  });

  return errors;
}

/**
 * Gets error instructions for a given error type
 * @param {string} errorType - The error type to get instructions for
 * @param {Object} spec - The full OpenAPI specification
 * @returns {string|null} The error instructions markdown if found, null otherwise
 */
function getErrorInstructions(errorType, spec) {
  // Look for instructions in the ErrorType schema
  const errorTypeSchema = spec.components.schemas.ErrorType;
  if (errorTypeSchema?.["x-error-instructions"]?.[errorType]) {
    return errorTypeSchema["x-error-instructions"][errorType];
  }
  return null;
}

/**
 * Replaces absolute URLs that start with baseUrl with relative links in generated content
 * Keeps errorLink as an absolute URL
 * @param {string} content - The content to process
 * @returns {string} Content with absolute URLs replaced by relative links
 */
function replaceAbsoluteUrls(content) {
  if (!baseUrl) return content;

  // Skip URLs in JSON examples (errorLink should remain as absolute URL)
  const parts = [];
  let inCodeBlock = false;
  let currentPart = "";

  content.split("\n").forEach((line) => {
    if (line.startsWith("```")) {
      inCodeBlock = !inCodeBlock;
      currentPart += `${line}\n`;

      if (!inCodeBlock) {
        // We've reached the end of a code block, add it without changes
        parts.push(currentPart);
        currentPart = "";
      }
    } else if (inCodeBlock) {
      // Inside a code block, don't replace URLs
      currentPart += `${line}\n`;
    } else {
      // Regular markdown text, replace absolute URLs with relative ones
      // Use a regex to match URLs that start with baseUrl
      const regex = new RegExp(`${baseUrl}([^\\s")]+)`, "g");
      const replacedLine = line.replace(regex, (match, urlPath) => {
        return `/${urlPath}`;
      });
      currentPart += `${replacedLine}\n`;
    }
  });

  // Add any remaining content
  if (currentPart) {
    parts.push(currentPart);
  }

  return parts.join("");
}

/**
 * Generates markdown documentation for API errors
 * @param {Object} spec - The parsed OpenAPI specification
 * @returns {string} Markdown formatted error documentation
 */
function generateErrorDocs(spec) {
  let markdown = `---
title: Errors
---

# API Errors

The CDP API uses conventional HTTP response codes to indicate the success or failure of an API request. 
In general:

- Codes in the \`2xx\` range indicate success
- Codes in the \`4xx\` range indicate an error that failed given the information provided (e.g., a 
  required parameter was omitted)
- Codes in the \`5xx\` range indicate an error on CDP's backend servers. 

  <Info>
  \`5xx\` errors are not a guarantee of failure; there's always the chance that the operation may have 
  succeeded in our back-end. Therefore, your application should treat the operation's status as 
  **unknown**.
  </Info>

Each error response includes:
- \`errorType\`: A machine-readable error code
- \`errorMessage\`: A human-readable message providing more detail
- \`correlationId\`: A unique identifier for the request that can help with debugging
- \`errorLink\`: A link to detailed documentation about the specific error type

`;

  // Group errors by status code and error type
  const errorsByStatus = new Map();
  const MAX_EXAMPLES = 3;

  Object.entries(spec.paths).forEach(([, pathObj]) => {
    const errors = extractErrorResponses(pathObj, spec);
    errors.forEach((error) => {
      if (!errorsByStatus.has(error.status)) {
        errorsByStatus.set(error.status, new Map());
      }
      const errorTypeMap = errorsByStatus.get(error.status);
      const { example } = error;
      const errorType = example?.errorType || "unknown";

      // Store all examples for this error type
      if (!errorTypeMap.has(errorType)) {
        errorTypeMap.set(errorType, {
          description: error.description,
          examples: [],
          instructions: getErrorInstructions(errorType, spec),
        });
      }

      // Add this example if it's unique and we haven't hit the limit
      const errorInfo = errorTypeMap.get(errorType);
      const isDuplicate = errorInfo.examples.some(
        (e) => JSON.stringify(e) === JSON.stringify(example),
      );
      if (!isDuplicate && errorInfo.examples.length < MAX_EXAMPLES) {
        errorInfo.examples.push(example);
      }
    });
  });

  // Sort by status code
  const sortedStatuses = Array.from(errorsByStatus.keys()).sort();

  // Generate documentation for each status code and its error types
  sortedStatuses.forEach((status) => {
    markdown += `## HTTP ${status}\n\n`;

    const errorTypeMap = errorsByStatus.get(status);
    const errorTypes = Array.from(errorTypeMap.entries());

    errorTypes.forEach(([errorType, error]) => {
      markdown += `### ${errorType}\n\n`;

      // Add error instructions if they exist
      if (error.instructions) {
        markdown += `${error.instructions}\n\n`;
      }

      // Add up to MAX_EXAMPLES examples for this error type
      error.examples.forEach((example, index) => {
        if (error.examples.length > 1) {
          markdown += `**Example ${index + 1}:**\n\n`;
        } else {
          markdown += `**Example error response:**\n\n`;
        }
        markdown += `\`\`\`json lines wrap\n${JSON.stringify(example, null, 2)}\n\`\`\`\n\n`;
      });
    });
  });

  return markdown;
}

openApiSpecs.forEach((spec) => {
  if (spec.id !== specId) {
    return;
  }

  console.log(`Reading ${spec.name} OpenAPI spec...`);

  try {
    // Read and parse YAML file
    const fileContents = fs.readFileSync(spec.specPath, "utf8");
    const openApiSpec = yaml.load(fileContents);

    // Generate error documentation
    const errorDocs = generateErrorDocs(openApiSpec);

    // Process the content to replace absolute URLs with relative links
    // This doesn't affect errorLink in JSON examples which will remain absolute
    const processedDocs = replaceAbsoluteUrls(errorDocs);

    // Write to output file
    fs.writeFileSync(spec.outputPath, processedDocs);
    console.log(`Generated error documentation at ${spec.outputPath}`);
  } catch (error) {
    console.error("Error processing OpenAPI spec:", error);
    process.exit(1);
  }
});


#!/usr/bin/env node

const fs = require("fs");
const path = require("path");

// Configuration
const OPENAPI_PATH = path.join(
  __dirname,
  "..",
  "api-reference",
  "v2",
  "cdp-api-v2.yaml",
);
const API_REFERENCE_DIR = path.join(
  __dirname,
  "..",
  "api-reference",
  "v2",
  "rest-api",
);

// Mapping of tag names to their overview file paths
const TAG_TO_FILE_MAPPING = {
  "EVM Accounts": "evm-accounts/evm-accounts.mdx",
  "EVM Smart Accounts": "evm-smart-accounts/evm-smart-accounts.mdx",
  "EVM Swaps": "evm-swaps/evm-swaps.mdx",
  "EVM Token Balances": "evm-token-balances/evm-token-balances.mdx",
  Faucets: "faucets/faucets.mdx",
  "Payments (Alpha)": "payments/payments.mdx",
  "Policy Engine": "policy-engine/policy-engine.mdx",
  "Solana Accounts": "solana-accounts/solana-accounts.mdx",
  "x402 Facilitator": "x402-facilitator/x402-facilitator.mdx",
};

// Simple YAML parser for tags section
function extractTagsFromYAML(yamlContent) {
  const tags = [];

  // Find the tags section - match until we hit a line that's not indented (next top-level key)
  const tagsMatch = yamlContent.match(/^tags:\s*\n((?:(?:  |\s{2,}).*\n)*)/m);

  if (!tagsMatch) {
    return tags;
  }

  const tagsSection = tagsMatch[1];

  // Split by tag entries (starting with "  - name:")
  const tagEntries = tagsSection
    .split(/(?=^  - name:)/m)
    .filter((entry) => entry.trim());

  for (const entry of tagEntries) {
    const nameMatch = entry.match(/name:\s*(.+)/);
    const descriptionMatch = entry.match(
      /description:\s*(?:\|-?\s*\n)?((?:(?:      |\s{6,}).*\n?)*)/,
    );

    if (nameMatch && descriptionMatch) {
      const name = nameMatch[1].trim();
      let description = descriptionMatch[1];

      // Clean up the description - preserve relative indentation
      const lines = description.split("\n");

      // Find the minimum indentation (excluding empty lines)
      const minIndent = lines
        .filter((line) => line.trim())
        .reduce((min, line) => {
          const indent = line.match(/^(\s*)/)[1].length;
          return Math.min(min, indent);
        }, Infinity);

      // Remove the base indentation while preserving relative indentation
      description = lines
        .map((line) => line.slice(minIndent))
        .join("\n")
        .trim();

      tags.push({ name, description });
    }
  }

  return tags;
}

// Function to read and parse the OpenAPI spec
function readOpenAPISpec() {
  try {
    const fileContents = fs.readFileSync(OPENAPI_PATH, "utf8");
    return fileContents;
  } catch (error) {
    console.error("Error reading OpenAPI spec:", error);
    process.exit(1);
  }
}

// Function to extract tag descriptions from OpenAPI spec
function extractTagDescriptions(yamlContent) {
  const tagDescriptions = {};
  const tags = extractTagsFromYAML(yamlContent);

  tags.forEach((tag) => {
    if (tag.name && tag.description) {
      tagDescriptions[tag.name] = tag.description;
    }
  });

  return tagDescriptions;
}

// Function to update MDX file with new description
function updateMDXFile(filePath, tagName, description) {
  const fullPath = path.join(API_REFERENCE_DIR, filePath);

  // Check if file exists
  if (!fs.existsSync(fullPath)) {
    console.warn(`Warning: File not found: ${fullPath}`);
    return false;
  }

  try {
    let content = fs.readFileSync(fullPath, "utf8");

    // Find the frontmatter section
    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n/);
    if (!frontmatterMatch) {
      console.warn(`Warning: No frontmatter found in ${filePath}`);
      return false;
    }

    const frontmatter = frontmatterMatch[1];

    // Create new content with updated description
    const newContent = `---
${frontmatter}
---

${description}
`;

    // Write the updated content
    fs.writeFileSync(fullPath, newContent, "utf8");
    console.log(`✓ Updated ${filePath}`);
    return true;
  } catch (error) {
    console.error(`Error updating ${filePath}:`, error);
    return false;
  }
}

// Main function
function main() {
  console.log("Starting OpenAPI overview pages update...\n");

  // Read OpenAPI spec
  const yamlContent = readOpenAPISpec();
  console.log("✓ OpenAPI spec loaded successfully\n");

  // Extract tag descriptions
  const tagDescriptions = extractTagDescriptions(yamlContent);
  console.log(
    `Found ${Object.keys(tagDescriptions).length} tags with descriptions\n`,
  );

  // Update each overview file
  let successCount = 0;
  let totalCount = 0;

  for (const [tagName, filePath] of Object.entries(TAG_TO_FILE_MAPPING)) {
    totalCount++;

    if (tagDescriptions[tagName]) {
      console.log(`Processing: ${tagName}`);
      if (updateMDXFile(filePath, tagName, tagDescriptions[tagName])) {
        successCount++;
      }
    } else {
      console.warn(`Warning: No description found for tag "${tagName}"`);
    }
    console.log("");
  }

  console.log(
    `\nUpdate complete! Successfully updated ${successCount}/${totalCount} files.`,
  );
}

// Run the script
main();


module.exports = {
  "*": "prettier --write --ignore-unknown",
};


Get information about a payment method for the current user.

Get Payment Method

Whether or not this payment method can perform buys.

Whether or not this payment method can perform deposits.

Whether or not this payment method can perform sells.

Whether or not this payment method can perform withdrawals.

Time at which this payment method was created.

Unique identifier for the payment method.

Time at which this payment method was updated.

The verified status of the payment method.

`Any` contains an arbitrary serialized protocol buffer message along with a
URL that describes the type of the serialized message.

Protobuf library provides support to pack/unpack Any values in the form
of utility functions or additional generated methods of the Any type.

Example 1: Pack and unpack a message in C++.

    Foo foo = ...;
    Any any;
    any.PackFrom(foo);
    ...
    if (any.UnpackTo(&foo)) {
      ...
    }

Example 2: Pack and unpack a message in Java.

    Foo foo = ...;
    Any any = Any.pack(foo);
    ...
    if (any.is(Foo.class)) {
      foo = any.unpack(Foo.class);
    }
    // or ...
    if (any.isSameTypeAs(Foo.getDefaultInstance())) {
      foo = any.unpack(Foo.getDefaultInstance());
    }

 Example 3: Pack and unpack a message in Python.

    foo = Foo(...)
    any = Any()
    any.Pack(foo)
    ...
    if any.Is(Foo.DESCRIPTOR):
      any.Unpack(foo)
      ...

 Example 4: Pack and unpack a message in Go

     foo := &pb.Foo{...}
     any, err := anypb.New(foo)
     if err != nil {
       ...
     }
     ...
     foo := &pb.Foo{}
     if err := any.UnmarshalTo(foo); err != nil {
       ...
     }

The pack methods provided by protobuf library will by default use
'type.googleapis.com/full.type.name' as the type URL and the unpack
methods only use the fully qualified type name after the last '/'
in the type URL, for example "foo.bar.com/x/y.z" will yield type
name "y.z".

JSON
====
The JSON representation of an `Any` value uses the regular
representation of the deserialized, embedded message, with an
additional field `@type` which contains the type URL. Example:

    package google.profile;
    message Person {
      string first_name = 1;
      string last_name = 2;
    }

    {
      "@type": "type.googleapis.com/google.profile.Person",
      "firstName": <string>,
      "lastName": <string>
    }

If the embedded message type is well-known and has a custom JSON
representation, that representation will be embedded adding a field
`value` which holds the custom JSON in addition to the `@type`
field. Example (for message [google.protobuf.Duration][]):

    {
      "@type": "type.googleapis.com/google.protobuf.Duration",
      "value": "1.212s"
    }

A URL/resource name that uniquely identifies the type of the serialized
protocol buffer message. This string must contain at least
one "/" character. The last segment of the URL's path must represent
the fully qualified name of the type (as in
`path/google.protobuf.Duration`). The name should be in a canonical form
(e.g., leading "." is not accepted).

In practice, teams usually precompile into the binary all types that they
expect it to use in the context of Any. However, for URLs which use the
scheme `http`, `https`, or no scheme, one can optionally set up a type
server that maps type URLs to message definitions as follows:

* If no scheme is provided, `https` is assumed.
* An HTTP GET on the URL must yield a [google.protobuf.Type][]
  value in binary format, or produce an error.
* Applications are allowed to cache lookup results based on the
  URL, or have them precompiled into a binary to avoid any
  lookup. Therefore, binary compatibility needs to be preserved
  on changes to types. (Use versioned type names to manage
  breaking changes.)

Note: this functionality is not currently available in the official
protobuf release, and it is not used for type URLs beginning with
type.googleapis.com. As of May 2023, there are no widely used type server
implementations and no plans to implement one.

Schemes other than `http`, `https` (or the empty scheme) might be
used with implementation specific semantics.

REST API

Get Payment Method

Path Parameters

Response