cloudflare 4.0.0 → 4.1.0

package/src/resources/r2/buckets/event-notifications.ts

@@ -0,0 +1,230 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../resource';
+import * as Core from '../../../core';
+
+export class EventNotifications extends APIResource {
+  /**
+   * Create event notification rule.
+   */
+  update(
+    bucketName: string,
+    queueId: string,
+    params: EventNotificationUpdateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<EventNotificationUpdateResponse> {
+    const { account_id, jurisdiction, ...body } = params;
+    return (
+      this._client.put(
+        `/accounts/${account_id}/event_notifications/r2/${bucketName}/configuration/queues/${queueId}`,
+        {
+          body,
+          ...options,
+          headers: {
+            ...(jurisdiction?.toString() != null ?
+              { 'cf-r2-jurisdiction': jurisdiction?.toString() }
+            : undefined),
+            ...options?.headers,
+          },
+        },
+      ) as Core.APIPromise<{ result: EventNotificationUpdateResponse }>
+    )._thenUnwrap((obj) => obj.result);
+  }
+
+  /**
+   * Delete an event notification rule. **If no body is provided, all rules for
+   * specified queue will be deleted**.
+   */
+  delete(
+    bucketName: string,
+    queueId: string,
+    params: EventNotificationDeleteParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<EventNotificationDeleteResponse> {
+    const { account_id, jurisdiction } = params;
+    return (
+      this._client.delete(
+        `/accounts/${account_id}/event_notifications/r2/${bucketName}/configuration/queues/${queueId}`,
+        {
+          ...options,
+          headers: {
+            ...(jurisdiction?.toString() != null ?
+              { 'cf-r2-jurisdiction': jurisdiction?.toString() }
+            : undefined),
+            ...options?.headers,
+          },
+        },
+      ) as Core.APIPromise<{ result: EventNotificationDeleteResponse }>
+    )._thenUnwrap((obj) => obj.result);
+  }
+
+  /**
+   * List all event notification rules for a bucket.
+   */
+  get(
+    bucketName: string,
+    params: EventNotificationGetParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<EventNotificationGetResponse> {
+    const { account_id, jurisdiction } = params;
+    return (
+      this._client.get(`/accounts/${account_id}/event_notifications/r2/${bucketName}/configuration`, {
+        ...options,
+        headers: {
+          ...(jurisdiction?.toString() != null ?
+            { 'cf-r2-jurisdiction': jurisdiction?.toString() }
+          : undefined),
+          ...options?.headers,
+        },
+      }) as Core.APIPromise<{ result: EventNotificationGetResponse }>
+    )._thenUnwrap((obj) => obj.result);
+  }
+}
+
+export type EventNotificationUpdateResponse = unknown;
+
+export type EventNotificationDeleteResponse = unknown;
+
+export interface EventNotificationGetResponse {
+  /**
+   * Name of the bucket.
+   */
+  bucketName?: string;
+
+  /**
+   * List of queues associated with the bucket.
+   */
+  queues?: Array<EventNotificationGetResponse.Queue>;
+}
+
+export namespace EventNotificationGetResponse {
+  export interface Queue {
+    /**
+     * Queue ID
+     */
+    queueId?: string;
+
+    /**
+     * Name of the queue
+     */
+    queueName?: string;
+
+    rules?: Array<Queue.Rule>;
+  }
+
+  export namespace Queue {
+    export interface Rule {
+      /**
+       * Array of R2 object actions that will trigger notifications
+       */
+      actions: Array<
+        'PutObject' | 'CopyObject' | 'DeleteObject' | 'CompleteMultipartUpload' | 'LifecycleDeletion'
+      >;
+
+      /**
+       * Timestamp when the rule was created
+       */
+      createdAt?: string;
+
+      /**
+       * A description that can be used to identify the event notification rule after
+       * creation
+       */
+      description?: string;
+
+      /**
+       * Notifications will be sent only for objects with this prefix
+       */
+      prefix?: string;
+
+      /**
+       * Rule ID
+       */
+      ruleId?: string;
+
+      /**
+       * Notifications will be sent only for objects with this suffix
+       */
+      suffix?: string;
+    }
+  }
+}
+
+export interface EventNotificationUpdateParams {
+  /**
+   * Path param: Account ID
+   */
+  account_id: string;
+
+  /**
+   * Body param: Array of rules to drive notifications
+   */
+  rules?: Array<EventNotificationUpdateParams.Rule>;
+
+  /**
+   * Header param: The bucket jurisdiction
+   */
+  jurisdiction?: 'default' | 'eu' | 'fedramp';
+}
+
+export namespace EventNotificationUpdateParams {
+  export interface Rule {
+    /**
+     * Array of R2 object actions that will trigger notifications
+     */
+    actions: Array<
+      'PutObject' | 'CopyObject' | 'DeleteObject' | 'CompleteMultipartUpload' | 'LifecycleDeletion'
+    >;
+
+    /**
+     * A description that can be used to identify the event notification rule after
+     * creation
+     */
+    description?: string;
+
+    /**
+     * Notifications will be sent only for objects with this prefix
+     */
+    prefix?: string;
+
+    /**
+     * Notifications will be sent only for objects with this suffix
+     */
+    suffix?: string;
+  }
+}
+
+export interface EventNotificationDeleteParams {
+  /**
+   * Path param: Account ID
+   */
+  account_id: string;
+
+  /**
+   * Header param: The bucket jurisdiction
+   */
+  jurisdiction?: 'default' | 'eu' | 'fedramp';
+}
+
+export interface EventNotificationGetParams {
+  /**
+   * Path param: Account ID
+   */
+  account_id: string;
+
+  /**
+   * Header param: The bucket jurisdiction
+   */
+  jurisdiction?: 'default' | 'eu' | 'fedramp';
+}
+
+export declare namespace EventNotifications {
+  export {
+    type EventNotificationUpdateResponse as EventNotificationUpdateResponse,
+    type EventNotificationDeleteResponse as EventNotificationDeleteResponse,
+    type EventNotificationGetResponse as EventNotificationGetResponse,
+    type EventNotificationUpdateParams as EventNotificationUpdateParams,
+    type EventNotificationDeleteParams as EventNotificationDeleteParams,
+    type EventNotificationGetParams as EventNotificationGetParams,
+  };
+}

package/src/resources/r2/buckets/index.ts

@@ -20,7 +20,15 @@ export {
   type CORSGetParams,
 } from './cors';
 export { Domains } from './domains/index';
-export { EventNotifications } from './event-notifications/index';
+export {
+  EventNotifications,
+  type EventNotificationUpdateResponse,
+  type EventNotificationDeleteResponse,
+  type EventNotificationGetResponse,
+  type EventNotificationUpdateParams,
+  type EventNotificationDeleteParams,
+  type EventNotificationGetParams,
+} from './event-notifications';
 export {
   Lifecycle,
   type LifecycleUpdateResponse,
@@ -28,6 +36,14 @@ export {
   type LifecycleUpdateParams,
   type LifecycleGetParams,
 } from './lifecycle';
+export {
+  Locks,
+  type LockUpdateResponse,
+  type LockGetResponse,
+  type LockUpdateParams,
+  type LockGetParams,
+} from './locks';
+export { Metrics, type MetricListResponse, type MetricListParams } from './metrics';
 export {
   SippyResource,
   type Provider,

package/src/resources/r2/buckets/locks.ts

@@ -0,0 +1,205 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../resource';
+import * as Core from '../../../core';
+
+export class Locks extends APIResource {
+  /**
+   * Set lock rules for a bucket
+   */
+  update(
+    bucketName: string,
+    params: LockUpdateParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<LockUpdateResponse> {
+    const { account_id, jurisdiction, ...body } = params;
+    return (
+      this._client.put(`/accounts/${account_id}/r2/buckets/${bucketName}/lock`, {
+        body,
+        ...options,
+        headers: {
+          ...(jurisdiction?.toString() != null ?
+            { 'cf-r2-jurisdiction': jurisdiction?.toString() }
+          : undefined),
+          ...options?.headers,
+        },
+      }) as Core.APIPromise<{ result: LockUpdateResponse }>
+    )._thenUnwrap((obj) => obj.result);
+  }
+
+  /**
+   * Get lock rules for a bucket
+   */
+  get(
+    bucketName: string,
+    params: LockGetParams,
+    options?: Core.RequestOptions,
+  ): Core.APIPromise<LockGetResponse> {
+    const { account_id, jurisdiction } = params;
+    return (
+      this._client.get(`/accounts/${account_id}/r2/buckets/${bucketName}/lock`, {
+        ...options,
+        headers: {
+          ...(jurisdiction?.toString() != null ?
+            { 'cf-r2-jurisdiction': jurisdiction?.toString() }
+          : undefined),
+          ...options?.headers,
+        },
+      }) as Core.APIPromise<{ result: LockGetResponse }>
+    )._thenUnwrap((obj) => obj.result);
+  }
+}
+
+export type LockUpdateResponse = unknown;
+
+export interface LockGetResponse {
+  rules?: Array<LockGetResponse.Rule>;
+}
+
+export namespace LockGetResponse {
+  export interface Rule {
+    /**
+     * Unique identifier for this rule
+     */
+    id: string;
+
+    /**
+     * Condition to apply a lock rule to an object for how long in seconds
+     */
+    condition:
+      | Rule.R2LockRuleAgeCondition
+      | Rule.R2LockRuleDateCondition
+      | Rule.R2LockRuleIndefiniteCondition;
+
+    /**
+     * Whether or not this rule is in effect
+     */
+    enabled: boolean;
+
+    /**
+     * Rule will only apply to objects/uploads in the bucket that start with the given
+     * prefix, an empty prefix can be provided to scope rule to all objects/uploads
+     */
+    prefix?: string;
+  }
+
+  export namespace Rule {
+    /**
+     * Condition to apply a lock rule to an object for how long in seconds
+     */
+    export interface R2LockRuleAgeCondition {
+      maxAgeSeconds: number;
+
+      type: 'Age';
+    }
+
+    /**
+     * Condition to apply a lock rule to an object until a specific date
+     */
+    export interface R2LockRuleDateCondition {
+      date: string;
+
+      type: 'Date';
+    }
+
+    /**
+     * Condition to apply a lock rule indefinitely
+     */
+    export interface R2LockRuleIndefiniteCondition {
+      type: 'Indefinite';
+    }
+  }
+}
+
+export interface LockUpdateParams {
+  /**
+   * Path param: Account ID
+   */
+  account_id: string;
+
+  /**
+   * Body param:
+   */
+  rules?: Array<LockUpdateParams.Rule>;
+
+  /**
+   * Header param: The bucket jurisdiction
+   */
+  jurisdiction?: 'default' | 'eu' | 'fedramp';
+}
+
+export namespace LockUpdateParams {
+  export interface Rule {
+    /**
+     * Unique identifier for this rule
+     */
+    id: string;
+
+    /**
+     * Condition to apply a lock rule to an object for how long in seconds
+     */
+    condition:
+      | Rule.R2LockRuleAgeCondition
+      | Rule.R2LockRuleDateCondition
+      | Rule.R2LockRuleIndefiniteCondition;
+
+    /**
+     * Whether or not this rule is in effect
+     */
+    enabled: boolean;
+
+    /**
+     * Rule will only apply to objects/uploads in the bucket that start with the given
+     * prefix, an empty prefix can be provided to scope rule to all objects/uploads
+     */
+    prefix?: string;
+  }
+
+  export namespace Rule {
+    /**
+     * Condition to apply a lock rule to an object for how long in seconds
+     */
+    export interface R2LockRuleAgeCondition {
+      maxAgeSeconds: number;
+
+      type: 'Age';
+    }
+
+    /**
+     * Condition to apply a lock rule to an object until a specific date
+     */
+    export interface R2LockRuleDateCondition {
+      date: string;
+
+      type: 'Date';
+    }
+
+    /**
+     * Condition to apply a lock rule indefinitely
+     */
+    export interface R2LockRuleIndefiniteCondition {
+      type: 'Indefinite';
+    }
+  }
+}
+
+export interface LockGetParams {
+  /**
+   * Path param: Account ID
+   */
+  account_id: string;
+
+  /**
+   * Header param: The bucket jurisdiction
+   */
+  jurisdiction?: 'default' | 'eu' | 'fedramp';
+}
+
+export declare namespace Locks {
+  export {
+    type LockUpdateResponse as LockUpdateResponse,
+    type LockGetResponse as LockGetResponse,
+    type LockUpdateParams as LockUpdateParams,
+    type LockGetParams as LockGetParams,
+  };
+}

package/src/resources/r2/buckets/metrics.ts

@@ -0,0 +1,161 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../resource';
+import * as Core from '../../../core';
+
+export class Metrics extends APIResource {
+  /**
+   * Get Storage/Object Count Metrics across all buckets in your account. Note that
+   * Account-Level Metrics may not immediately reflect the latest data.
+   */
+  list(params: MetricListParams, options?: Core.RequestOptions): Core.APIPromise<MetricListResponse> {
+    const { account_id } = params;
+    return (
+      this._client.get(`/accounts/${account_id}/r2/metrics`, options) as Core.APIPromise<{
+        result: MetricListResponse;
+      }>
+    )._thenUnwrap((obj) => obj.result);
+  }
+}
+
+/**
+ * Metrics based on the class they belong to
+ */
+export interface MetricListResponse {
+  /**
+   * Metrics based on what state they are in(uploaded or published)
+   */
+  infrequentAccess?: MetricListResponse.InfrequentAccess;
+
+  /**
+   * Metrics based on what state they are in(uploaded or published)
+   */
+  standard?: MetricListResponse.Standard;
+}
+
+export namespace MetricListResponse {
+  /**
+   * Metrics based on what state they are in(uploaded or published)
+   */
+  export interface InfrequentAccess {
+    /**
+     * Metrics on number of objects/amount of storage used
+     */
+    published?: InfrequentAccess.Published;
+
+    /**
+     * Metrics on number of objects/amount of storage used
+     */
+    uploaded?: InfrequentAccess.Uploaded;
+  }
+
+  export namespace InfrequentAccess {
+    /**
+     * Metrics on number of objects/amount of storage used
+     */
+    export interface Published {
+      /**
+       * Amount of
+       */
+      metadataSize?: number;
+
+      /**
+       * Number of objects stored
+       */
+      objects?: number;
+
+      /**
+       * Amount of storage used by object data
+       */
+      payloadSize?: number;
+    }
+
+    /**
+     * Metrics on number of objects/amount of storage used
+     */
+    export interface Uploaded {
+      /**
+       * Amount of
+       */
+      metadataSize?: number;
+
+      /**
+       * Number of objects stored
+       */
+      objects?: number;
+
+      /**
+       * Amount of storage used by object data
+       */
+      payloadSize?: number;
+    }
+  }
+
+  /**
+   * Metrics based on what state they are in(uploaded or published)
+   */
+  export interface Standard {
+    /**
+     * Metrics on number of objects/amount of storage used
+     */
+    published?: Standard.Published;
+
+    /**
+     * Metrics on number of objects/amount of storage used
+     */
+    uploaded?: Standard.Uploaded;
+  }
+
+  export namespace Standard {
+    /**
+     * Metrics on number of objects/amount of storage used
+     */
+    export interface Published {
+      /**
+       * Amount of
+       */
+      metadataSize?: number;
+
+      /**
+       * Number of objects stored
+       */
+      objects?: number;
+
+      /**
+       * Amount of storage used by object data
+       */
+      payloadSize?: number;
+    }
+
+    /**
+     * Metrics on number of objects/amount of storage used
+     */
+    export interface Uploaded {
+      /**
+       * Amount of
+       */
+      metadataSize?: number;
+
+      /**
+       * Number of objects stored
+       */
+      objects?: number;
+
+      /**
+       * Amount of storage used by object data
+       */
+      payloadSize?: number;
+    }
+  }
+}
+
+export interface MetricListParams {
+  /**
+   * Account ID
+   */
+  account_id: string;
+}
+
+export declare namespace Metrics {
+  export { type MetricListResponse as MetricListResponse, type MetricListParams as MetricListParams };
+}

package/src/resources/r2/buckets/sippy.ts

@@ -144,12 +144,12 @@ export declare namespace SippyUpdateParams {
     /**
      * Body param: R2 bucket to copy objects to
      */
-    destination?: SippyUpdateParams.R2EnableSippyAws.Destination;
+    destination?: R2EnableSippyAws.Destination;
 
     /**
      * Body param: AWS S3 bucket to copy objects from
      */
-    source?: SippyUpdateParams.R2EnableSippyAws.Source;
+    source?: R2EnableSippyAws.Source;
 
     /**
      * Header param: The bucket jurisdiction
@@ -222,12 +222,12 @@ export declare namespace SippyUpdateParams {
     /**
      * Body param: R2 bucket to copy objects to
      */
-    destination?: SippyUpdateParams.R2EnableSippyGcs.Destination;
+    destination?: R2EnableSippyGcs.Destination;
 
     /**
      * Body param: GCS bucket to copy objects from
      */
-    source?: SippyUpdateParams.R2EnableSippyGcs.Source;
+    source?: R2EnableSippyGcs.Source;
 
     /**
      * Header param: The bucket jurisdiction

package/src/resources/radar/ai/ai.ts

@@ -9,18 +9,24 @@ import {
 } from './timeseries-groups';
 import * as BotsAPI from './bots/bots';
 import { Bots } from './bots/bots';
+import * as InferenceAPI from './inference/inference';
+import { Inference } from './inference/inference';
 
 export class AI extends APIResource {
+  inference: InferenceAPI.Inference = new InferenceAPI.Inference(this._client);
   bots: BotsAPI.Bots = new BotsAPI.Bots(this._client);
   timeseriesGroups: TimeseriesGroupsAPI.TimeseriesGroups = new TimeseriesGroupsAPI.TimeseriesGroups(
     this._client,
   );
 }
 
+AI.Inference = Inference;
 AI.Bots = Bots;
 AI.TimeseriesGroups = TimeseriesGroups;
 
 export declare namespace AI {
+  export { Inference as Inference };
+
   export { Bots as Bots };
 
   export {

package/src/resources/radar/ai/index.ts

@@ -2,6 +2,7 @@
 
 export { AI } from './ai';
 export { Bots } from './bots/index';
+export { Inference } from './inference/index';
 export {
   TimeseriesGroups,
   type TimeseriesGroupUserAgentResponse,

package/src/resources/radar/ai/inference/index.ts

@@ -0,0 +1,11 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Inference } from './inference';
+export {
+  Summary,
+  type SummaryModelResponse,
+  type SummaryTaskResponse,
+  type SummaryModelParams,
+  type SummaryTaskParams,
+} from './summary';
+export { TimeseriesGroups } from './timeseries-groups/index';