cloudflare 4.0.0 → 4.1.0

package/src/resources/custom-certificates/custom-certificates.ts

@@ -4,9 +4,9 @@ import { APIResource } from '../../resource';
 import * as Core from '../../core';
 import * as KeylessCertificatesAPI from '../keyless-certificates';
 import * as PrioritizeAPI from './prioritize';
-import { Prioritize, PrioritizeUpdateParams, PrioritizeUpdateResponse } from './prioritize';
+import { Prioritize, PrioritizeUpdateParams } from './prioritize';
 import * as CustomHostnamesAPI from '../custom-hostnames/custom-hostnames';
-import { V4PagePaginationArray, type V4PagePaginationArrayParams } from '../../pagination';
+import { SinglePage, V4PagePaginationArray, type V4PagePaginationArrayParams } from '../../pagination';
 
 export class CustomCertificates extends APIResource {
   prioritize: PrioritizeAPI.Prioritize = new PrioritizeAPI.Prioritize(this._client);
@@ -99,6 +99,8 @@ export class CustomCertificates extends APIResource {
 
 export class CustomCertificatesV4PagePaginationArray extends V4PagePaginationArray<CustomCertificate> {}
 
+export class CustomCertificatesSinglePage extends SinglePage<CustomCertificate> {}
+
 export interface CustomCertificate {
   /**
    * Identifier
@@ -362,9 +364,5 @@ export interface CustomCertificateGetParams {
 CustomCertificates.Prioritize = Prioritize;
 
 export declare namespace CustomCertificates {
-  export {
-    Prioritize as Prioritize,
-    type PrioritizeUpdateResponse as PrioritizeUpdateResponse,
-    type PrioritizeUpdateParams as PrioritizeUpdateParams,
-  };
+  export { Prioritize as Prioritize, type PrioritizeUpdateParams as PrioritizeUpdateParams };
 }

package/src/resources/custom-certificates/index.ts

@@ -1,4 +1,4 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 export { CustomCertificates } from './custom-certificates';
-export { Prioritize, type PrioritizeUpdateResponse, type PrioritizeUpdateParams } from './prioritize';
+export { Prioritize, type PrioritizeUpdateParams } from './prioritize';

package/src/resources/custom-certificates/prioritize.ts

@@ -3,6 +3,7 @@
 import { APIResource } from '../../resource';
 import * as Core from '../../core';
 import * as CustomCertificatesAPI from './custom-certificates';
+import { CustomCertificatesSinglePage } from './custom-certificates';
 
 export class Prioritize extends APIResource {
   /**
@@ -13,19 +14,16 @@ export class Prioritize extends APIResource {
   update(
     params: PrioritizeUpdateParams,
     options?: Core.RequestOptions,
-  ): Core.APIPromise<PrioritizeUpdateResponse> {
+  ): Core.PagePromise<CustomCertificatesSinglePage, CustomCertificatesAPI.CustomCertificate> {
     const { zone_id, ...body } = params;
-    return (
-      this._client.put(`/zones/${zone_id}/custom_certificates/prioritize`, {
-        body,
-        ...options,
-      }) as Core.APIPromise<{ result: PrioritizeUpdateResponse }>
-    )._thenUnwrap((obj) => obj.result);
+    return this._client.getAPIList(
+      `/zones/${zone_id}/custom_certificates/prioritize`,
+      CustomCertificatesSinglePage,
+      { body, method: 'put', ...options },
+    );
   }
 }
 
-export type PrioritizeUpdateResponse = Array<CustomCertificatesAPI.CustomCertificate>;
-
 export interface PrioritizeUpdateParams {
   /**
    * Path param: Identifier
@@ -56,8 +54,7 @@ export namespace PrioritizeUpdateParams {
 }
 
 export declare namespace Prioritize {
-  export {
-    type PrioritizeUpdateResponse as PrioritizeUpdateResponse,
-    type PrioritizeUpdateParams as PrioritizeUpdateParams,
-  };
+  export { type PrioritizeUpdateParams as PrioritizeUpdateParams };
 }
+
+export { CustomCertificatesSinglePage };

package/src/resources/custom-hostnames/certificate-pack/certificate-pack.ts

@@ -0,0 +1,27 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../resource';
+import * as CertificatesAPI from './certificates';
+import {
+  CertificateDeleteParams,
+  CertificateDeleteResponse,
+  CertificateUpdateParams,
+  CertificateUpdateResponse,
+  Certificates,
+} from './certificates';
+
+export class CertificatePack extends APIResource {
+  certificates: CertificatesAPI.Certificates = new CertificatesAPI.Certificates(this._client);
+}
+
+CertificatePack.Certificates = Certificates;
+
+export declare namespace CertificatePack {
+  export {
+    Certificates as Certificates,
+    type CertificateUpdateResponse as CertificateUpdateResponse,
+    type CertificateDeleteResponse as CertificateDeleteResponse,
+    type CertificateUpdateParams as CertificateUpdateParams,
+    type CertificateDeleteParams as CertificateDeleteParams,
+  };
+}

package/src/resources/custom-hostnames/certificate-pack/certificates.ts

@@ -0,0 +1,391 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../resource';
+import * as Core from '../../../core';
+import * as Shared from '../../shared';
+import * as CustomHostnamesAPI from '../custom-hostnames';
+
+export class Certificates extends APIResource {
+  /**
+   * Replace a single custom certificate within a certificate pack that contains two
+   * bundled certificates. The replacement must adhere to the following constraints.
+   * You can only replace an RSA certificate with another RSA certificate or an ECDSA
+   * certificate with another ECDSA certificate.
+   */
+  update(
+    customHostnameId: string,
+    certificatePackId: string,
+    certificateId: string,
+    params: CertificateUpdateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<CertificateUpdateResponse> {
+    const { zone_id, ...body } = params;
+    return (
+      this._client.put(
+        `/zones/${zone_id}/custom_hostnames/${customHostnameId}/certificate_pack/${certificatePackId}/certificates/${certificateId}`,
+        { body, ...options },
+      ) as Core.APIPromise<{ result: CertificateUpdateResponse }>
+    )._thenUnwrap((obj) => obj.result);
+  }
+
+  /**
+   * Delete a single custom certificate from a certificate pack that contains two
+   * bundled certificates. Deletion is subject to the following constraints. You
+   * cannot delete a certificate if it is the only remaining certificate in the pack.
+   * At least one certificate must remain in the pack.
+   */
+  delete(
+    customHostnameId: string,
+    certificatePackId: string,
+    certificateId: string,
+    params: CertificateDeleteParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<CertificateDeleteResponse> {
+    const { zone_id } = params;
+    return this._client.delete(
+      `/zones/${zone_id}/custom_hostnames/${customHostnameId}/certificate_pack/${certificatePackId}/certificates/${certificateId}`,
+      options,
+    );
+  }
+}
+
+export interface CertificateUpdateResponse {
+  /**
+   * Identifier
+   */
+  id: string;
+
+  /**
+   * The custom hostname that will point to your hostname via CNAME.
+   */
+  hostname: string;
+
+  ssl: CertificateUpdateResponse.SSL;
+
+  /**
+   * This is the time the hostname was created.
+   */
+  created_at?: string;
+
+  /**
+   * Unique key/value metadata for this hostname. These are per-hostname (customer)
+   * settings.
+   */
+  custom_metadata?: Record<string, string>;
+
+  /**
+   * a valid hostname that’s been added to your DNS zone as an A, AAAA, or CNAME
+   * record.
+   */
+  custom_origin_server?: string;
+
+  /**
+   * A hostname that will be sent to your custom origin server as SNI for TLS
+   * handshake. This can be a valid subdomain of the zone or custom origin server
+   * name or the string ':request_host_header:' which will cause the host header in
+   * the request to be used as SNI. Not configurable with default/fallback origin
+   * server.
+   */
+  custom_origin_sni?: string;
+
+  /**
+   * This is a record which can be placed to activate a hostname.
+   */
+  ownership_verification?: CertificateUpdateResponse.OwnershipVerification;
+
+  /**
+   * This presents the token to be served by the given http url to activate a
+   * hostname.
+   */
+  ownership_verification_http?: CertificateUpdateResponse.OwnershipVerificationHTTP;
+
+  /**
+   * Status of the hostname's activation.
+   */
+  status?:
+    | 'active'
+    | 'pending'
+    | 'active_redeploying'
+    | 'moved'
+    | 'pending_deletion'
+    | 'deleted'
+    | 'pending_blocked'
+    | 'pending_migration'
+    | 'pending_provisioned'
+    | 'test_pending'
+    | 'test_active'
+    | 'test_active_apex'
+    | 'test_blocked'
+    | 'test_failed'
+    | 'provisioned'
+    | 'blocked';
+
+  /**
+   * These are errors that were encountered while trying to activate a hostname.
+   */
+  verification_errors?: Array<string>;
+}
+
+export namespace CertificateUpdateResponse {
+  export interface SSL {
+    /**
+     * Custom hostname SSL identifier tag.
+     */
+    id?: string;
+
+    /**
+     * A ubiquitous bundle has the highest probability of being verified everywhere,
+     * even by clients using outdated or unusual trust stores. An optimal bundle uses
+     * the shortest chain and newest intermediates. And the force bundle verifies the
+     * chain, but does not otherwise modify it.
+     */
+    bundle_method?: CustomHostnamesAPI.BundleMethod;
+
+    /**
+     * The Certificate Authority that will issue the certificate
+     */
+    certificate_authority?: Shared.CertificateCA;
+
+    /**
+     * If a custom uploaded certificate is used.
+     */
+    custom_certificate?: string;
+
+    /**
+     * The identifier for the Custom CSR that was used.
+     */
+    custom_csr_id?: string;
+
+    /**
+     * The key for a custom uploaded certificate.
+     */
+    custom_key?: string;
+
+    /**
+     * The time the custom certificate expires on.
+     */
+    expires_on?: string;
+
+    /**
+     * A list of Hostnames on a custom uploaded certificate.
+     */
+    hosts?: Array<string>;
+
+    /**
+     * The issuer on a custom uploaded certificate.
+     */
+    issuer?: string;
+
+    /**
+     * Domain control validation (DCV) method used for this hostname.
+     */
+    method?: CustomHostnamesAPI.DCVMethod;
+
+    /**
+     * The serial number on a custom uploaded certificate.
+     */
+    serial_number?: string;
+
+    settings?: SSL.Settings;
+
+    /**
+     * The signature on a custom uploaded certificate.
+     */
+    signature?: string;
+
+    /**
+     * Status of the hostname's SSL certificates.
+     */
+    status?:
+      | 'initializing'
+      | 'pending_validation'
+      | 'deleted'
+      | 'pending_issuance'
+      | 'pending_deployment'
+      | 'pending_deletion'
+      | 'pending_expiration'
+      | 'expired'
+      | 'active'
+      | 'initializing_timed_out'
+      | 'validation_timed_out'
+      | 'issuance_timed_out'
+      | 'deployment_timed_out'
+      | 'deletion_timed_out'
+      | 'pending_cleanup'
+      | 'staging_deployment'
+      | 'staging_active'
+      | 'deactivating'
+      | 'inactive'
+      | 'backup_issued'
+      | 'holding_deployment';
+
+    /**
+     * Level of validation to be used for this hostname. Domain validation (dv) must be
+     * used.
+     */
+    type?: CustomHostnamesAPI.DomainValidationType;
+
+    /**
+     * The time the custom certificate was uploaded.
+     */
+    uploaded_on?: string;
+
+    /**
+     * Domain validation errors that have been received by the certificate authority
+     * (CA).
+     */
+    validation_errors?: Array<SSL.ValidationError>;
+
+    validation_records?: Array<SSL.ValidationRecord>;
+
+    /**
+     * Indicates whether the certificate covers a wildcard.
+     */
+    wildcard?: boolean;
+  }
+
+  export namespace SSL {
+    export interface Settings {
+      /**
+       * An allowlist of ciphers for TLS termination. These ciphers must be in the
+       * BoringSSL format.
+       */
+      ciphers?: Array<string>;
+
+      /**
+       * Whether or not Early Hints is enabled.
+       */
+      early_hints?: 'on' | 'off';
+
+      /**
+       * Whether or not HTTP2 is enabled.
+       */
+      http2?: 'on' | 'off';
+
+      /**
+       * The minimum TLS version supported.
+       */
+      min_tls_version?: '1.0' | '1.1' | '1.2' | '1.3';
+
+      /**
+       * Whether or not TLS 1.3 is enabled.
+       */
+      tls_1_3?: 'on' | 'off';
+    }
+
+    export interface ValidationError {
+      /**
+       * A domain validation error.
+       */
+      message?: string;
+    }
+
+    export interface ValidationRecord {
+      /**
+       * The set of email addresses that the certificate authority (CA) will use to
+       * complete domain validation.
+       */
+      emails?: Array<string>;
+
+      /**
+       * The content that the certificate authority (CA) will expect to find at the
+       * http_url during the domain validation.
+       */
+      http_body?: string;
+
+      /**
+       * The url that will be checked during domain validation.
+       */
+      http_url?: string;
+
+      /**
+       * The hostname that the certificate authority (CA) will check for a TXT record
+       * during domain validation .
+       */
+      txt_name?: string;
+
+      /**
+       * The TXT record that the certificate authority (CA) will check during domain
+       * validation.
+       */
+      txt_value?: string;
+    }
+  }
+
+  /**
+   * This is a record which can be placed to activate a hostname.
+   */
+  export interface OwnershipVerification {
+    /**
+     * DNS Name for record.
+     */
+    name?: string;
+
+    /**
+     * DNS Record type.
+     */
+    type?: 'txt';
+
+    /**
+     * Content for the record.
+     */
+    value?: string;
+  }
+
+  /**
+   * This presents the token to be served by the given http url to activate a
+   * hostname.
+   */
+  export interface OwnershipVerificationHTTP {
+    /**
+     * Token to be served.
+     */
+    http_body?: string;
+
+    /**
+     * The HTTP URL that will be checked during custom hostname verification and where
+     * the customer should host the token.
+     */
+    http_url?: string;
+  }
+}
+
+export interface CertificateDeleteResponse {
+  /**
+   * Identifier
+   */
+  id?: string;
+}
+
+export interface CertificateUpdateParams {
+  /**
+   * Path param: Identifier
+   */
+  zone_id: string;
+
+  /**
+   * Body param: If a custom uploaded certificate is used.
+   */
+  custom_certificate: string;
+
+  /**
+   * Body param: The key for a custom uploaded certificate.
+   */
+  custom_key: string;
+}
+
+export interface CertificateDeleteParams {
+  /**
+   * Identifier
+   */
+  zone_id: string;
+}
+
+export declare namespace Certificates {
+  export {
+    type CertificateUpdateResponse as CertificateUpdateResponse,
+    type CertificateDeleteResponse as CertificateDeleteResponse,
+    type CertificateUpdateParams as CertificateUpdateParams,
+    type CertificateDeleteParams as CertificateDeleteParams,
+  };
+}

package/src/resources/custom-hostnames/certificate-pack/index.ts

@@ -0,0 +1,10 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { CertificatePack } from './certificate-pack';
+export {
+  Certificates,
+  type CertificateUpdateResponse,
+  type CertificateDeleteResponse,
+  type CertificateUpdateParams,
+  type CertificateDeleteParams,
+} from './certificates';

package/src/resources/custom-hostnames/custom-hostnames.ts

@@ -14,10 +14,13 @@ import {
   FallbackOriginUpdateParams,
   FallbackOriginUpdateResponse,
 } from './fallback-origin';
+import * as CertificatePackAPI from './certificate-pack/certificate-pack';
+import { CertificatePack } from './certificate-pack/certificate-pack';
 import { V4PagePaginationArray, type V4PagePaginationArrayParams } from '../../pagination';
 
 export class CustomHostnames extends APIResource {
   fallbackOrigin: FallbackOriginAPI.FallbackOrigin = new FallbackOriginAPI.FallbackOrigin(this._client);
+  certificatePack: CertificatePackAPI.CertificatePack = new CertificatePackAPI.CertificatePack(this._client);
 
   /**
    * Add a new custom hostname and request that an SSL certificate be issued for it.
@@ -26,7 +29,10 @@ export class CustomHostnames extends APIResource {
    * 'email' will send an email to the WHOIS contacts on file for the base domain
    * plus hostmaster, postmaster, webmaster, admin, administrator. If http is used
    * and the domain is not already pointing to the Managed CNAME host, the PATCH
-   * method must be used once it is (to complete validation).
+   * method must be used once it is (to complete validation). Enable bundling of
+   * certificates using the custom_cert_bundle field. The bundling process requires
+   * the following condition One certificate in the bundle must use an RSA, and the
+   * other must use an ECDSA.
    */
   create(
     params: CustomHostnameCreateParams,
@@ -71,7 +77,10 @@ export class CustomHostnames extends APIResource {
    * Modify SSL configuration for a custom hostname. When sent with SSL config that
    * matches existing config, used to indicate that hostname should pass domain
    * control validation (DCV). Can also be used to change validation type, e.g., from
-   * 'http' to 'email'.
+   * 'http' to 'email'. Bundle an existing certificate with another certificate by
+   * using the "custom_cert_bundle" field. The bundling process supports combining
+   * certificates as long as the following condition is met. One certificate must use
+   * the RSA algorithm, and the other must use the ECDSA algorithm.
    */
   edit(
     customHostnameId: string,
@@ -1703,6 +1712,11 @@ export namespace CustomHostnameCreateParams {
      */
     cloudflare_branding?: boolean;
 
+    /**
+     * Array of custom certificate and key pairs (1 or 2 pairs allowed)
+     */
+    custom_cert_bundle?: Array<SSL.CustomCERTBundle>;
+
     /**
      * If a custom uploaded certificate is used.
      */
@@ -1736,6 +1750,18 @@ export namespace CustomHostnameCreateParams {
   }
 
   export namespace SSL {
+    export interface CustomCERTBundle {
+      /**
+       * If a custom uploaded certificate is used.
+       */
+      custom_certificate: string;
+
+      /**
+       * The key for a custom uploaded certificate.
+       */
+      custom_key: string;
+    }
+
     /**
      * SSL specific settings.
      */
@@ -1868,6 +1894,11 @@ export namespace CustomHostnameEditParams {
      */
     cloudflare_branding?: boolean;
 
+    /**
+     * Array of custom certificate and key pairs (1 or 2 pairs allowed)
+     */
+    custom_cert_bundle?: Array<SSL.CustomCERTBundle>;
+
     /**
      * If a custom uploaded certificate is used.
      */
@@ -1901,6 +1932,18 @@ export namespace CustomHostnameEditParams {
   }
 
   export namespace SSL {
+    export interface CustomCERTBundle {
+      /**
+       * If a custom uploaded certificate is used.
+       */
+      custom_certificate: string;
+
+      /**
+       * The key for a custom uploaded certificate.
+       */
+      custom_key: string;
+    }
+
     /**
      * SSL specific settings.
      */
@@ -1942,6 +1985,7 @@ export interface CustomHostnameGetParams {
 }
 
 CustomHostnames.FallbackOrigin = FallbackOrigin;
+CustomHostnames.CertificatePack = CertificatePack;
 
 export declare namespace CustomHostnames {
   export {
@@ -1953,4 +1997,6 @@ export declare namespace CustomHostnames {
     type FallbackOriginDeleteParams as FallbackOriginDeleteParams,
     type FallbackOriginGetParams as FallbackOriginGetParams,
   };
+
+  export { CertificatePack as CertificatePack };
 }

package/src/resources/custom-hostnames/index.ts

@@ -1,5 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+export { CertificatePack } from './certificate-pack/index';
 export { CustomHostnames } from './custom-hostnames';
 export {
   FallbackOrigin,