@distilled.cloud/cloudflare 0.0.0 → 0.2.0-alpha

package/src/services/brand-protection.ts

@@ -0,0 +1,553 @@
+/**
+ * Cloudflare BRAND-PROTECTION API
+ *
+ * Generated from Cloudflare TypeScript SDK.
+ * DO NOT EDIT - regenerate with: bun scripts/generate.ts --service brand-protection
+ */
+
+import * as Schema from "effect/Schema";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import * as API from "../client/api.ts";
+import * as T from "../traits";
+import type { Credentials } from "../credentials";
+import { type DefaultErrors } from "../errors";
+import { UploadableSchema } from "../schemas";
+
+// =============================================================================
+// BrandProtection
+// =============================================================================
+
+export interface SubmitBrandProtectionRequest {
+  accountId: string;
+}
+
+export const SubmitBrandProtectionRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      path: "/accounts/{account_id}/brand-protection/submit",
+    }),
+  ) as unknown as Schema.Schema<SubmitBrandProtectionRequest>;
+
+export interface SubmitBrandProtectionResponse {
+  skippedUrls?: Record<string, unknown>[] | null;
+  submittedUrls?: Record<string, unknown>[] | null;
+}
+
+export const SubmitBrandProtectionResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    skippedUrls: Schema.optional(
+      Schema.Union([Schema.Array(Schema.Struct({})), Schema.Null]),
+    ),
+    submittedUrls: Schema.optional(
+      Schema.Union([Schema.Array(Schema.Struct({})), Schema.Null]),
+    ),
+  }).pipe(
+    Schema.encodeKeys({
+      skippedUrls: "skipped_urls",
+      submittedUrls: "submitted_urls",
+    }),
+  ) as unknown as Schema.Schema<SubmitBrandProtectionResponse>;
+
+export type SubmitBrandProtectionError = DefaultErrors;
+
+export const submitBrandProtection: API.OperationMethod<
+  SubmitBrandProtectionRequest,
+  SubmitBrandProtectionResponse,
+  SubmitBrandProtectionError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: SubmitBrandProtectionRequest,
+  output: SubmitBrandProtectionResponse,
+  errors: [],
+}));
+
+// =============================================================================
+// InfoBrandProtection
+// =============================================================================
+
+export interface UrlInfoBrandProtectionRequest {
+  accountId: string;
+}
+
+export const UrlInfoBrandProtectionRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/accounts/{account_id}/brand-protection/url-info",
+    }),
+  ) as unknown as Schema.Schema<UrlInfoBrandProtectionRequest>;
+
+export type UrlInfoBrandProtectionResponse = Record<string, unknown>[];
+
+export const UrlInfoBrandProtectionResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Array(
+    Schema.Struct({}),
+  ) as unknown as Schema.Schema<UrlInfoBrandProtectionResponse>;
+
+export type UrlInfoBrandProtectionError = DefaultErrors;
+
+export const urlInfoBrandProtection: API.OperationMethod<
+  UrlInfoBrandProtectionRequest,
+  UrlInfoBrandProtectionResponse,
+  UrlInfoBrandProtectionError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: UrlInfoBrandProtectionRequest,
+  output: UrlInfoBrandProtectionResponse,
+  errors: [],
+}));
+
+// =============================================================================
+// Logo
+// =============================================================================
+
+export interface CreateLogoRequest {
+  /** Path param: */
+  accountId: string;
+  /** Query param: */
+  matchType?: string;
+  /** Query param: */
+  tag?: string;
+  /** Query param: */
+  threshold?: number;
+  /** Body param: */
+  image?: File | Blob;
+}
+
+export const CreateLogoRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  matchType: Schema.optional(Schema.String).pipe(T.HttpQuery("match_type")),
+  tag: Schema.optional(Schema.String).pipe(T.HttpQuery("tag")),
+  threshold: Schema.optional(Schema.Number).pipe(T.HttpQuery("threshold")),
+  image: Schema.optional(UploadableSchema.pipe(T.HttpFormDataFile())),
+}).pipe(
+  T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/brand-protection/logos",
+    contentType: "multipart",
+  }),
+) as unknown as Schema.Schema<CreateLogoRequest>;
+
+export interface CreateLogoResponse {
+  id?: number | null;
+  tag?: string | null;
+  uploadPath?: string | null;
+}
+
+export const CreateLogoResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  id: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+  tag: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  uploadPath: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+}).pipe(
+  Schema.encodeKeys({ id: "id", tag: "tag", uploadPath: "upload_path" }),
+) as unknown as Schema.Schema<CreateLogoResponse>;
+
+export type CreateLogoError = DefaultErrors;
+
+export const createLogo: API.OperationMethod<
+  CreateLogoRequest,
+  CreateLogoResponse,
+  CreateLogoError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: CreateLogoRequest,
+  output: CreateLogoResponse,
+  errors: [],
+}));
+
+export interface DeleteLogoRequest {
+  logoId: string;
+  accountId: string;
+}
+
+export const DeleteLogoRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  logoId: Schema.String.pipe(T.HttpPath("logoId")),
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+}).pipe(
+  T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/brand-protection/logos/{logoId}",
+  }),
+) as unknown as Schema.Schema<DeleteLogoRequest>;
+
+export type DeleteLogoResponse = unknown;
+
+export const DeleteLogoResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Schema<DeleteLogoResponse>;
+
+export type DeleteLogoError = DefaultErrors;
+
+export const deleteLogo: API.OperationMethod<
+  DeleteLogoRequest,
+  DeleteLogoResponse,
+  DeleteLogoError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: DeleteLogoRequest,
+  output: DeleteLogoResponse,
+  errors: [],
+}));
+
+// =============================================================================
+// LogoMatch
+// =============================================================================
+
+export interface GetLogoMatchRequest {
+  /** Path param: */
+  accountId: string;
+  /** Query param: */
+  limit?: string;
+  /** Query param: */
+  logoId?: string[];
+  /** Query param: */
+  offset?: string;
+}
+
+export const GetLogoMatchRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  limit: Schema.optional(Schema.String).pipe(T.HttpQuery("limit")),
+  logoId: Schema.optional(Schema.Array(Schema.String)).pipe(
+    T.HttpQuery("logo_id"),
+  ),
+  offset: Schema.optional(Schema.String).pipe(T.HttpQuery("offset")),
+}).pipe(
+  T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/brand-protection/logo-matches",
+  }),
+) as unknown as Schema.Schema<GetLogoMatchRequest>;
+
+export interface GetLogoMatchResponse {
+  matches?: Record<string, unknown>[] | null;
+  total?: number | null;
+}
+
+export const GetLogoMatchResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  matches: Schema.optional(
+    Schema.Union([Schema.Array(Schema.Struct({})), Schema.Null]),
+  ),
+  total: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+}) as unknown as Schema.Schema<GetLogoMatchResponse>;
+
+export type GetLogoMatchError = DefaultErrors;
+
+export const getLogoMatch: API.OperationMethod<
+  GetLogoMatchRequest,
+  GetLogoMatchResponse,
+  GetLogoMatchError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: GetLogoMatchRequest,
+  output: GetLogoMatchResponse,
+  errors: [],
+}));
+
+export interface DownloadLogoMatchRequest {
+  /** Path param: */
+  accountId: string;
+  /** Query param: */
+  limit?: string;
+  /** Query param: */
+  logoId?: string[];
+  /** Query param: */
+  offset?: string;
+}
+
+export const DownloadLogoMatchRequest =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    limit: Schema.optional(Schema.String).pipe(T.HttpQuery("limit")),
+    logoId: Schema.optional(Schema.Array(Schema.String)).pipe(
+      T.HttpQuery("logo_id"),
+    ),
+    offset: Schema.optional(Schema.String).pipe(T.HttpQuery("offset")),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      path: "/accounts/{account_id}/brand-protection/logo-matches/download",
+    }),
+  ) as unknown as Schema.Schema<DownloadLogoMatchRequest>;
+
+export interface DownloadLogoMatchResponse {
+  matches?: Record<string, unknown>[] | null;
+  total?: number | null;
+}
+
+export const DownloadLogoMatchResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+    matches: Schema.optional(
+      Schema.Union([Schema.Array(Schema.Struct({})), Schema.Null]),
+    ),
+    total: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+  }) as unknown as Schema.Schema<DownloadLogoMatchResponse>;
+
+export type DownloadLogoMatchError = DefaultErrors;
+
+export const downloadLogoMatch: API.OperationMethod<
+  DownloadLogoMatchRequest,
+  DownloadLogoMatchResponse,
+  DownloadLogoMatchError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: DownloadLogoMatchRequest,
+  output: DownloadLogoMatchResponse,
+  errors: [],
+}));
+
+// =============================================================================
+// Match
+// =============================================================================
+
+export interface GetMatchRequest {
+  /** Path param: */
+  accountId: string;
+  /** Query param: */
+  id?: string;
+  /** Query param: */
+  includeDomainId?: boolean;
+  /** Query param: */
+  limit?: number;
+  /** Query param: */
+  offset?: number;
+}
+
+export const GetMatchRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  id: Schema.optional(Schema.String).pipe(T.HttpQuery("id")),
+  includeDomainId: Schema.optional(Schema.Boolean).pipe(
+    T.HttpQuery("include_domain_id"),
+  ),
+  limit: Schema.optional(Schema.Number).pipe(T.HttpQuery("limit")),
+  offset: Schema.optional(Schema.Number).pipe(T.HttpQuery("offset")),
+}).pipe(
+  T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/brand-protection/matches",
+  }),
+) as unknown as Schema.Schema<GetMatchRequest>;
+
+export interface GetMatchResponse {
+  matches?: Record<string, unknown>[] | null;
+  total?: number | null;
+}
+
+export const GetMatchResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  matches: Schema.optional(
+    Schema.Union([Schema.Array(Schema.Struct({})), Schema.Null]),
+  ),
+  total: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+}) as unknown as Schema.Schema<GetMatchResponse>;
+
+export type GetMatchError = DefaultErrors;
+
+export const getMatch: API.OperationMethod<
+  GetMatchRequest,
+  GetMatchResponse,
+  GetMatchError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: GetMatchRequest,
+  output: GetMatchResponse,
+  errors: [],
+}));
+
+export interface DownloadMatchRequest {
+  /** Path param: */
+  accountId: string;
+  /** Query param: */
+  id?: string;
+  /** Query param: */
+  includeDomainId?: boolean;
+  /** Query param: */
+  limit?: number;
+  /** Query param: */
+  offset?: number;
+}
+
+export const DownloadMatchRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  id: Schema.optional(Schema.String).pipe(T.HttpQuery("id")),
+  includeDomainId: Schema.optional(Schema.Boolean).pipe(
+    T.HttpQuery("include_domain_id"),
+  ),
+  limit: Schema.optional(Schema.Number).pipe(T.HttpQuery("limit")),
+  offset: Schema.optional(Schema.Number).pipe(T.HttpQuery("offset")),
+}).pipe(
+  T.Http({
+    method: "GET",
+    path: "/accounts/{account_id}/brand-protection/matches/download",
+  }),
+) as unknown as Schema.Schema<DownloadMatchRequest>;
+
+export interface DownloadMatchResponse {
+  matches?: Record<string, unknown>[] | null;
+  total?: number | null;
+}
+
+export const DownloadMatchResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  matches: Schema.optional(
+    Schema.Union([Schema.Array(Schema.Struct({})), Schema.Null]),
+  ),
+  total: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+}) as unknown as Schema.Schema<DownloadMatchResponse>;
+
+export type DownloadMatchError = DefaultErrors;
+
+export const downloadMatch: API.OperationMethod<
+  DownloadMatchRequest,
+  DownloadMatchResponse,
+  DownloadMatchError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: DownloadMatchRequest,
+  output: DownloadMatchResponse,
+  errors: [],
+}));
+
+// =============================================================================
+// Query
+// =============================================================================
+
+export interface CreateQueryRequest {
+  /** Path param: */
+  accountId: string;
+  /** Query param: */
+  id?: string;
+  /** Query param: */
+  queryScan?: boolean;
+  /** Query param: */
+  queryTag?: string;
+  /** Body param: */
+  maxTime?: string | null;
+  /** Body param: */
+  minTime?: string | null;
+  /** Body param: */
+  bodyScan?: boolean;
+  /** Body param: */
+  stringMatches?: unknown;
+  /** Body param: */
+  bodyTag?: string;
+}
+
+export const CreateQueryRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  id: Schema.optional(Schema.String).pipe(T.HttpQuery("id")),
+  queryScan: Schema.optional(Schema.Boolean).pipe(T.HttpQuery("query_scan")),
+  queryTag: Schema.optional(Schema.String).pipe(T.HttpQuery("query_tag")),
+  maxTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  minTime: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  bodyScan: Schema.optional(Schema.Boolean),
+  stringMatches: Schema.optional(Schema.Unknown),
+  bodyTag: Schema.optional(Schema.String),
+}).pipe(
+  Schema.encodeKeys({
+    maxTime: "max_time",
+    minTime: "min_time",
+    bodyScan: "body_scan",
+    stringMatches: "string_matches",
+    bodyTag: "body_tag",
+  }),
+  T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/brand-protection/queries",
+  }),
+) as unknown as Schema.Schema<CreateQueryRequest>;
+
+export type CreateQueryResponse = unknown;
+
+export const CreateQueryResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Schema<CreateQueryResponse>;
+
+export type CreateQueryError = DefaultErrors;
+
+export const createQuery: API.OperationMethod<
+  CreateQueryRequest,
+  CreateQueryResponse,
+  CreateQueryError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: CreateQueryRequest,
+  output: CreateQueryResponse,
+  errors: [],
+}));
+
+export interface DeleteQueryRequest {
+  /** Path param: */
+  accountId: string;
+  /** Query param: */
+  id?: string;
+  /** Query param: */
+  scan?: boolean;
+  /** Query param: */
+  tag?: string;
+}
+
+export const DeleteQueryRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  id: Schema.optional(Schema.String).pipe(T.HttpQuery("id")),
+  scan: Schema.optional(Schema.Boolean).pipe(T.HttpQuery("scan")),
+  tag: Schema.optional(Schema.String).pipe(T.HttpQuery("tag")),
+}).pipe(
+  T.Http({
+    method: "DELETE",
+    path: "/accounts/{account_id}/brand-protection/queries",
+  }),
+) as unknown as Schema.Schema<DeleteQueryRequest>;
+
+export type DeleteQueryResponse = unknown;
+
+export const DeleteQueryResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Schema<DeleteQueryResponse>;
+
+export type DeleteQueryError = DefaultErrors;
+
+export const deleteQuery: API.OperationMethod<
+  DeleteQueryRequest,
+  DeleteQueryResponse,
+  DeleteQueryError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: DeleteQueryRequest,
+  output: DeleteQueryResponse,
+  errors: [],
+}));
+
+export interface BulkQueryRequest {
+  /** Path param: */
+  accountId: string;
+  /** Body param: */
+  queries?: Record<string, unknown>[];
+}
+
+export const BulkQueryRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
+  accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  queries: Schema.optional(Schema.Array(Schema.Struct({}))),
+}).pipe(
+  T.Http({
+    method: "POST",
+    path: "/accounts/{account_id}/brand-protection/queries/bulk",
+  }),
+) as unknown as Schema.Schema<BulkQueryRequest>;
+
+export type BulkQueryResponse = unknown;
+
+export const BulkQueryResponse =
+  /*@__PURE__*/ /*#__PURE__*/ Schema.Unknown as unknown as Schema.Schema<BulkQueryResponse>;
+
+export type BulkQueryError = DefaultErrors;
+
+export const bulkQuery: API.OperationMethod<
+  BulkQueryRequest,
+  BulkQueryResponse,
+  BulkQueryError,
+  Credentials | HttpClient.HttpClient
+> = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
+  input: BulkQueryRequest,
+  output: BulkQueryResponse,
+  errors: [],
+}));