@salefony/api-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,2310 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AdminResources: () => admin_exports,
+  AdminTypes: () => admin_exports2,
+  ApiClient: () => ApiClient,
+  BaseResource: () => BaseResource,
+  CommonTypes: () => common_exports,
+  CrudResource: () => CrudResource,
+  FrontstoreResources: () => frontstore_exports,
+  FrontstoreTypes: () => frontstore_exports2,
+  QueryBuilder: () => QueryBuilder,
+  SalefonyApiSdk: () => SalefonyApiSdk,
+  SalefonyAuthError: () => SalefonyAuthError,
+  SalefonyError: () => SalefonyError,
+  SalefonyNotFoundError: () => SalefonyNotFoundError,
+  SalefonyValidationError: () => SalefonyValidationError,
+  SchemaTypes: () => schema_exports,
+  apiKeyColumns: () => apiKeyColumns,
+  collectionColumns: () => collectionColumns,
+  columns: () => columns,
+  contentColumns: () => contentColumns,
+  createSDK: () => createSDK,
+  createSDKFromEnv: () => createSDKFromEnv,
+  datasourceColumns: () => datasourceColumns,
+  languageColumns: () => languageColumns,
+  layoutColumns: () => layoutColumns,
+  metadataColumns: () => metadataColumns,
+  navigationColumns: () => navigationColumns,
+  projectColumns: () => projectColumns,
+  sectionColumns: () => sectionColumns,
+  sectorColumns: () => sectorColumns,
+  storeColumns: () => storeColumns,
+  unwrap: () => unwrap,
+  unwrapList: () => unwrapList,
+  unwrapMeta: () => unwrapMeta,
+  vendorColumns: () => vendorColumns
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/client.ts
+var import_axios = __toESM(require("axios"));
+
+// src/core/errors.ts
+var SalefonyError = class _SalefonyError extends Error {
+  constructor(message, statusCode, rawError, requestContext) {
+    const contextMsg = requestContext?.url ? ` [${requestContext.method || "GET"} ${requestContext.url}]` : "";
+    super(`${message}${contextMsg}`);
+    this.statusCode = statusCode;
+    this.rawError = rawError;
+    this.requestContext = requestContext;
+    this.name = "SalefonyError";
+    Object.setPrototypeOf(this, _SalefonyError.prototype);
+  }
+  /** Validation hataları için field-wise detaylar */
+  get details() {
+    return this.rawError?.errors ?? this.rawError;
+  }
+  /** Hata sunucudan mı geldi (5xx) */
+  get isServerError() {
+    return (this.statusCode ?? 0) >= 500;
+  }
+  /** İstemci hatası mı (4xx) */
+  get isClientError() {
+    const s = this.statusCode ?? 0;
+    return s >= 400 && s < 500;
+  }
+};
+var SalefonyAuthError = class extends SalefonyError {
+  constructor(message, statusCode = 401, rawError, requestContext) {
+    super(message, statusCode, rawError, requestContext);
+    this.name = "SalefonyAuthError";
+  }
+};
+var SalefonyValidationError = class extends SalefonyError {
+  constructor(message, statusCode = 400, rawError, requestContext) {
+    super(message, statusCode, rawError, requestContext);
+    this.name = "SalefonyValidationError";
+  }
+};
+var SalefonyNotFoundError = class extends SalefonyError {
+  constructor(message, rawError, requestContext) {
+    super(message, 404, rawError, requestContext);
+    this.name = "SalefonyNotFoundError";
+  }
+};
+
+// src/core/client.ts
+var ApiClient = class {
+  constructor(config) {
+    this.config = config;
+    this.axiosInstance = import_axios.default.create({
+      baseURL: config.baseUrl,
+      timeout: config.timeout || 3e4,
+      headers: {
+        "Content-Type": "application/json",
+        ...config.headers
+      }
+    });
+    this.initializeInterceptors();
+    this.updateAuthHeaders();
+  }
+  axiosInstance;
+  initializeInterceptors() {
+    this.axiosInstance.interceptors.request.use((config) => {
+      if (this.config.debug) {
+        console.log(`%c[SDK Request] %c${config.method?.toUpperCase()} %c${config.url}`, "color: #3b82f6; font-weight: bold", "color: #10b981", "color: #6b7280");
+      }
+      return config;
+    });
+    this.axiosInstance.interceptors.response.use(
+      (response) => {
+        if (this.config.debug) {
+          console.log(`%c[SDK Response] %c${response.status} %c${response.config.url}`, "color: #3b82f6; font-weight: bold", "color: #10b981", "color: #6b7280");
+        }
+        return response;
+      },
+      async (error) => {
+        const { config, response } = error;
+        const shouldRetry = config && this.config.retries && (!config.__retryCount || config.__retryCount < this.config.retries);
+        const isRetryableError = !response || response.status >= 500 && response.status <= 599;
+        if (shouldRetry && isRetryableError) {
+          config.__retryCount = (config.__retryCount || 0) + 1;
+          const delay = config.__retryCount * 1e3;
+          if (this.config.debug) {
+            console.warn(`[SDK Retry] Attempt ${config.__retryCount} for ${config.url}. Waiting ${delay}ms...`);
+          }
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          return this.axiosInstance(config);
+        }
+        if ((0, import_axios.isAxiosError)(error)) {
+          const status = error.response?.status;
+          const message = error.response?.data?.message || error.response?.data?.error || error.message;
+          const requestContext = error.config ? { method: error.config.method, url: error.config.url } : void 0;
+          switch (status) {
+            case 401:
+            case 403:
+              throw new SalefonyAuthError(message, status, error.response?.data, requestContext);
+            case 404:
+              throw new SalefonyNotFoundError(message, error.response?.data, requestContext);
+            case 400:
+            case 422:
+              throw new SalefonyValidationError(message, status, error.response?.data, requestContext);
+            default:
+              throw new SalefonyError(message, status, error.response?.data, requestContext);
+          }
+        }
+        throw new SalefonyError(error instanceof Error ? error.message : "Unknown error");
+      }
+    );
+  }
+  updateAuthHeaders() {
+    if (this.config.apiKey) {
+      this.axiosInstance.defaults.headers.common["x-api-key"] = this.config.apiKey;
+    }
+    if (this.config.authToken) {
+      this.axiosInstance.defaults.headers.common["Authorization"] = `Bearer ${this.config.authToken}`;
+    }
+    if (this.config.vendorKey) {
+      this.axiosInstance.defaults.headers.common["x-vendor-key"] = this.config.vendorKey;
+    }
+  }
+  /**
+   * Bearer token ayarlar (Chainable)
+   */
+  setAuthToken(token) {
+    this.axiosInstance.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+    return this;
+  }
+  /**
+   * Vendor API anahtarı ayarlar (Chainable)
+   */
+  setVendorKey(key) {
+    this.axiosInstance.defaults.headers.common["x-vendor-key"] = key;
+    return this;
+  }
+  /**
+   * Ekstra headerlar ekler (Chainable)
+   */
+  setExtraHeaders(headers) {
+    Object.assign(this.axiosInstance.defaults.headers.common, headers);
+    return this;
+  }
+  /**
+   * Bearer token temizler (Chainable)
+   */
+  clearAuth() {
+    delete this.axiosInstance.defaults.headers.common["Authorization"];
+    return this;
+  }
+  get instance() {
+    return this.axiosInstance;
+  }
+};
+
+// src/resources/admin/index.ts
+var admin_exports = {};
+__export(admin_exports, {
+  ApiKeyResource: () => ApiKeyResource,
+  AuthResource: () => AuthResource,
+  CloudflareResource: () => CloudflareResource,
+  CollectionResource: () => CollectionResource,
+  ContentResource: () => ContentResource,
+  CustomDataResource: () => CustomDataResource,
+  DatasourceResource: () => DatasourceResource,
+  GoogleResource: () => GoogleResource,
+  LanguageResource: () => LanguageResource,
+  LayoutResource: () => LayoutResource,
+  MediaResource: () => MediaResource,
+  MetadataResource: () => MetadataResource,
+  NavigationResource: () => NavigationResource,
+  ProjectResource: () => ProjectResource,
+  PurchaseResource: () => PurchaseResource,
+  ReviewResource: () => ReviewResource,
+  SEOResource: () => SEOResource,
+  SectionResource: () => SectionResource,
+  SectorResource: () => SectorResource,
+  SettingsResource: () => SettingsResource,
+  StoreResource: () => StoreResource,
+  SubscriptionResource: () => SubscriptionResource,
+  ThemeResource: () => ThemeResource,
+  VendorResource: () => VendorResource,
+  WebmailResource: () => WebmailResource,
+  apiKeyColumns: () => apiKeyColumns,
+  collectionColumns: () => collectionColumns,
+  contentColumns: () => contentColumns,
+  datasourceColumns: () => datasourceColumns,
+  languageColumns: () => languageColumns,
+  layoutColumns: () => layoutColumns,
+  metadataColumns: () => metadataColumns,
+  navigationColumns: () => navigationColumns,
+  projectColumns: () => projectColumns,
+  sectionColumns: () => sectionColumns,
+  sectorColumns: () => sectorColumns,
+  storeColumns: () => storeColumns,
+  vendorColumns: () => vendorColumns
+});
+
+// src/core/cache.ts
+var SdkCache = class {
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * @param key Cache key
+   * @param ttl Time to live in milliseconds (default 30s)
+   */
+  set(key, data, ttl = 3e4) {
+    this.cache.set(key, {
+      data,
+      expiry: Date.now() + ttl
+    });
+  }
+  get(key) {
+    const cached = this.cache.get(key);
+    if (!cached) return null;
+    if (Date.now() > cached.expiry) {
+      this.cache.delete(key);
+      return null;
+    }
+    return cached.data;
+  }
+  clear() {
+    this.cache.clear();
+  }
+};
+var sdkCache = new SdkCache();
+
+// src/resources/base.ts
+var BaseResource = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+  }
+  async request(config, options) {
+    const cacheKey = options?.cache ? `${config.method}:${config.url}:${JSON.stringify(config.params || config.data)}` : null;
+    if (cacheKey) {
+      const cached = sdkCache.get(cacheKey);
+      if (cached) return cached;
+    }
+    const response = await this.httpClient.request({
+      ...config,
+      headers: { ...config.headers, ...options?.headers }
+    });
+    if (cacheKey && options?.cache) {
+      sdkCache.set(cacheKey, response.data, options.cache);
+    }
+    return response.data;
+  }
+};
+var QueryBuilder = class {
+  constructor(resource) {
+    this.resource = resource;
+  }
+  args = {};
+  /** Add columns (dot notation) - typed for autocomplete */
+  columns(...cols) {
+    this.args.columns = [...this.args.columns || [], ...cols];
+    return this;
+  }
+  /** Add filter (LINQ Where) */
+  where(where) {
+    this.args.filter = { ...this.args.filter, ...where };
+    this.args.where = { ...this.args.where, ...where };
+    return this;
+  }
+  /** Add filter (alias) */
+  filter(filter) {
+    this.args.filter = { ...this.args.filter, ...filter };
+    return this;
+  }
+  /** Sort: "field:asc" or "field:desc" */
+  sort(sort) {
+    this.args.sort = sort;
+    return this;
+  }
+  /** Artan sıralama (LINQ OrderBy) */
+  orderBy(orderBy) {
+    const str = typeof orderBy === "object" && !Array.isArray(orderBy) ? `${Object.keys(orderBy)[0]}:${orderBy[Object.keys(orderBy)[0]] || "asc"}` : String(orderBy);
+    this.args.sort = str;
+    return this;
+  }
+  /** Azalan sıralama (LINQ OrderByDescending) */
+  orderByDescending(field) {
+    const f = typeof field === "string" ? field : Object.keys(field)[0];
+    this.args.sort = `${f}:desc`;
+    return this;
+  }
+  /** @deprecated Use columns() */
+  include(include) {
+    this.args.include = include;
+    return this;
+  }
+  /** @deprecated Use columns() */
+  select(select) {
+    this.args.select = select;
+    return this;
+  }
+  /** Alınacak kayıt sayısı (LINQ Take) */
+  take(take) {
+    this.args.take = take;
+    this.args.paginate = { ...this.args.paginate, limit: take };
+    return this;
+  }
+  /** Atlanacak kayıt sayısı (LINQ Skip) */
+  skip(skip) {
+    this.args.skip = skip;
+    this.args.paginate = { ...this.args.paginate, page: Math.floor(skip / (this.args.paginate?.limit || 20)) + 1 };
+    return this;
+  }
+  /** Sorguyu çalıştır - liste döner (LINQ ToList) */
+  async toList(options) {
+    const listParams = {
+      ...this.args.columns?.length && { columns: this.args.columns },
+      ...this.args.filter && { filter: this.args.filter },
+      ...this.args.where && { where: this.args.where },
+      ...this.args.paginate && { paginate: this.args.paginate },
+      ...this.args.sort && { sort: this.args.sort },
+      ...this.args.take != null && { take: this.args.take },
+      ...this.args.skip != null && { skip: this.args.skip },
+      ...this.args.include && { include: this.args.include }
+    };
+    return this.resource.list(listParams, options);
+  }
+  /** Sorguyu çalıştır - liste döner (execute alias) */
+  async execute(options) {
+    return this.toList(options);
+  }
+  /** İlk kaydı getir, yoksa hata (LINQ First) */
+  async first(options) {
+    const args = { ...this.args, take: 1, skip: 0 };
+    const res = await this.resource.list(args, options);
+    const items = res.data ?? [];
+    if (items.length === 0) throw new Error("Sequence contains no elements");
+    return { data: items[0], meta: res.meta };
+  }
+  /** İlk kaydı getir, yoksa null (LINQ FirstOrDefault) */
+  async firstOrDefault(options) {
+    try {
+      const res = await this.first(options);
+      return res;
+    } catch {
+      return { data: null };
+    }
+  }
+  /** Tek kayıt bekle, 0 veya 2+ ise hata (LINQ Single) */
+  async single(options) {
+    const args = { ...this.args, take: 2 };
+    const res = await this.resource.list(args, options);
+    const items = res.data ?? [];
+    if (items.length === 0) throw new Error("Sequence contains no elements");
+    if (items.length > 1) throw new Error("Sequence contains more than one element");
+    return { data: items[0], meta: res.meta };
+  }
+  /** Tek kayıt bekle, yoksa null (LINQ SingleOrDefault) */
+  async singleOrDefault(options) {
+    try {
+      return await this.single(options);
+    } catch {
+      return { data: null };
+    }
+  }
+  /** Kayıt sayısı (LINQ Count) */
+  async count(options) {
+    return this.resource.count({ where: this.args.where }, options);
+  }
+  /** En az bir kayıt var mı (LINQ Any) */
+  async any(options) {
+    const n = await this.count(options);
+    return n > 0;
+  }
+};
+var CrudResource = class extends BaseResource {
+  constructor(httpClient, path) {
+    super(httpClient);
+    this.path = path;
+  }
+  /**
+   * LINQ tarzı fluent query başlatır (boş)
+   */
+  query() {
+    return new QueryBuilder(this);
+  }
+  /**
+   * LINQ tarzı chain başlatır - where ile.
+   * @example sdk.admin.collections.where({ isActive: true }).orderBy({ order: 'asc' }).take(10).toList()
+   */
+  where(where) {
+    return new QueryBuilder(this).where(where);
+  }
+  // ─── Backend-driven API (columns, filter, paginate, sort) ───────────────────
+  /**
+   * Get a single resource by ID.
+   * @param idOrParams - ID string or { id, columns?, language? }
+   * @example
+   * sdk.admin.collections.get('xyz');
+   * sdk.admin.collections.get({ id: 'xyz', columns: ['id', 'title', 'translations.*', 'parent.id'] });
+   */
+  async get(idOrParams, options) {
+    const resolved = typeof idOrParams === "string" ? { id: idOrParams } : idOrParams;
+    const id = resolved.id;
+    const cols = resolved.columns;
+    const lang = resolved.language;
+    const legacy = resolved;
+    const backendArgs = {
+      where: { id },
+      ...cols && { columns: Array.isArray(cols) ? cols : [cols] },
+      ...lang && { language: lang }
+    };
+    if (legacy.include != null) backendArgs.include = legacy.include;
+    if (legacy.select != null) backendArgs.select = legacy.select;
+    return this.request({
+      method: "GET",
+      url: `${this.path}/findUnique`,
+      params: { q: JSON.stringify(backendArgs) }
+    }, options);
+  }
+  /**
+   * List resources with columns, filter, paginate, sort.
+   * @example
+   * sdk.admin.collections.list({
+   *   columns: ['id', 'title', 'translations.*', 'parent.id'],
+   *   filter: { isActive: true },
+   *   paginate: { page: 1, limit: 20 },
+   *   sort: 'order:asc'
+   * });
+   */
+  async list(params, options) {
+    if (!params) {
+      return this.request({
+        method: "GET",
+        url: `${this.path}/findMany`
+      }, options);
+    }
+    const backendArgs = {};
+    if (params.columns) {
+      backendArgs.columns = Array.isArray(params.columns) ? params.columns : [params.columns];
+    }
+    if (params.filter) backendArgs.filter = params.filter;
+    if (params.where) backendArgs.where = params.where;
+    if (params.paginate) {
+      backendArgs.page = params.paginate.page ?? 1;
+      backendArgs.limit = params.paginate.limit ?? 20;
+    }
+    if (params.take != null) backendArgs.take = params.take;
+    if (params.skip != null) backendArgs.skip = params.skip;
+    if (params.sort) backendArgs.sort = params.sort;
+    if (params.search) backendArgs.search = params.search;
+    if (params.language) backendArgs.language = params.language;
+    if (params.orderBy) backendArgs.orderBy = params.orderBy;
+    if (params.include) backendArgs.include = params.include;
+    return this.request({
+      method: "GET",
+      url: `${this.path}/findMany`,
+      params: { q: JSON.stringify(backendArgs) }
+    }, options);
+  }
+  /**
+   * Edit (update) a resource by ID (Cloudflare-style).
+   * @example await client.admin.collections.edit('xyz', { name: 'New Name' })
+   */
+  async edit(id, data, options) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${id}`,
+      data
+    }, options);
+  }
+  /**
+   * Delete a resource by ID (Cloudflare-style).
+   * @example await client.admin.collections.delete('xyz')
+   */
+  async deleteById(id, options) {
+    await this.request({
+      method: "DELETE",
+      url: `${this.path}/${id}`
+    }, options);
+  }
+  // ─── Legacy / Prisma-style API (Geriye uyumluluk) ───────────────────────────
+  /** @deprecated Use list() instead */
+  async findMany(args, options) {
+    return this.list(args, options);
+  }
+  async count(args, options) {
+    const response = await this.request({
+      method: "GET",
+      url: `${this.path}/count`,
+      params: args ? { q: JSON.stringify(args) } : void 0
+    }, options);
+    return response.count || 0;
+  }
+  /** @deprecated Use list() with take: 1 */
+  async findFirst(args, options) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/findFirst`,
+      params: args ? { q: JSON.stringify(args) } : void 0
+    }, options);
+  }
+  /** @deprecated Use get() instead */
+  async findUnique(args, options) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/findUnique`,
+      params: { q: JSON.stringify(args) }
+    }, options);
+  }
+  async create(data, options) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/create`,
+      data
+    }, options);
+  }
+  async update(where, data, options) {
+    return this.request({
+      method: "PATCH",
+      url: `${this.path}/update`,
+      data: { where, data }
+    }, options);
+  }
+  /** @deprecated Use deleteById() instead */
+  async delete(where, options) {
+    return this.request({
+      method: "DELETE",
+      url: `${this.path}/delete`,
+      data: { where }
+    }, options);
+  }
+};
+
+// src/resources/admin/vendor.ts
+var vendorColumns = (...cols) => cols;
+var VendorResource = class extends CrudResource {
+  constructor(httpClient, path = "/api/admin/vendors") {
+    super(httpClient, path);
+  }
+  async deactivate(id) {
+    return this.update({ id }, { isActive: false });
+  }
+  async activate(id) {
+    return this.update({ id }, { isActive: true });
+  }
+};
+
+// src/resources/admin/section.ts
+var sectionColumns = (...cols) => cols;
+var SectionResource = class extends CrudResource {
+  constructor(httpClient) {
+    super(httpClient, "/api/admin/sections");
+  }
+};
+
+// src/resources/admin/theme.ts
+var ThemeResource = class extends BaseResource {
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  async getAll() {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/themes"
+    });
+  }
+  async getInstalled() {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/themes/installed"
+    });
+  }
+  async install(themeId) {
+    return this.request({
+      method: "POST",
+      url: "/api/admin/themes/install",
+      data: { themeId }
+    });
+  }
+  async getById(id) {
+    return this.request({
+      method: "GET",
+      url: `/api/admin/themes/${id}`
+    });
+  }
+};
+
+// src/resources/admin/layout.ts
+var layoutColumns = (...cols) => cols;
+var LayoutResource = class extends CrudResource {
+  constructor(httpClient, path = "/api/admin/layouts") {
+    super(httpClient, path);
+  }
+  async getLayout(id) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${id}/layout`
+    });
+  }
+  async updateLayout(id, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${id}/layout`,
+      data
+    });
+  }
+  async getEditInfo(previewUrl) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/edit`,
+      params: { previewUrl }
+    });
+  }
+  async updateEditInfo(previewUrl, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/edit`,
+      params: { previewUrl },
+      data
+    });
+  }
+  async getTranslate(id, language = "en", source) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${id}/translate`,
+      params: { language, source }
+    });
+  }
+  async updateTranslate(id, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${id}/translate`,
+      data
+    });
+  }
+};
+
+// src/resources/admin/settings.ts
+var SettingsResource = class extends BaseResource {
+  path = "/api/admin/settings";
+  constructor(httpClient, path) {
+    super(httpClient);
+    if (path) this.path = path;
+  }
+  async get() {
+    return this.request({
+      method: "GET",
+      url: this.path
+    });
+  }
+  async update(data) {
+    return this.request({
+      method: "POST",
+      url: this.path,
+      data
+    });
+  }
+  async initialize() {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/initialize`
+    });
+  }
+  async getLinking() {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/linking`
+    });
+  }
+  async deleteLinking(id) {
+    return this.request({
+      method: "DELETE",
+      url: `${this.path}/linking`,
+      data: { id }
+    });
+  }
+  async getSiteLinking() {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/sitelinking`
+    });
+  }
+  async updateSiteLinking(data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/sitelinking`,
+      data
+    });
+  }
+  async getTranslate(id, source) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${id}/translate`,
+      params: { source }
+    });
+  }
+  async updateTranslate(id, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${id}/translate`,
+      data
+    });
+  }
+};
+
+// src/resources/admin/api-key.ts
+var apiKeyColumns = (...cols) => cols;
+var ApiKeyResource = class extends CrudResource {
+  constructor(httpClient, path = "/api/admin/api-keys") {
+    super(httpClient, path);
+  }
+  async revoke(id) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/${id}/revoke`
+    });
+  }
+};
+
+// src/resources/admin/datasource.ts
+var datasourceColumns = (...cols) => cols;
+var DatasourceResource = class extends CrudResource {
+  constructor(httpClient, path = "/api/admin/datasource") {
+    super(httpClient, path);
+  }
+  async getById(id) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${id}`
+    });
+  }
+  async updateLinking(id, linking) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${id}/linking`,
+      data: { linking }
+    });
+  }
+  async getTranslate(id, source) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${id}/translate`,
+      params: { source }
+    });
+  }
+  async updateTranslate(id, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${id}/translate`,
+      data
+    });
+  }
+};
+
+// src/resources/admin/metadata.ts
+var metadataColumns = (...cols) => cols;
+var MetadataResource = class extends CrudResource {
+  constructor(httpClient, path = "/api/admin/metadata") {
+    super(httpClient, path);
+  }
+  /** Get metadata by ID (backend GET /:id) */
+  async getById(id) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${id}`
+    });
+  }
+  /** @deprecated Use edit(id, data) instead */
+  async updateById(id, data) {
+    return this.edit(id, data);
+  }
+  /** Delete metadata (backend DELETE /:id) - Cloudflare-style */
+  async deleteById(id) {
+    await this.request({
+      method: "DELETE",
+      url: `${this.path}/${id}`
+    });
+  }
+  /**
+   * Get metadata entry form
+   */
+  async getEntryForm(metadataId) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${metadataId}/entries`
+    });
+  }
+  /**
+   * Create a meta entry
+   */
+  async createEntry(metadataId, data) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/${metadataId}/entries`,
+      data
+    });
+  }
+  /**
+   * Update a meta entry
+   */
+  async updateEntry(metadataId, entryId, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${metadataId}/entries/${entryId}`,
+      data
+    });
+  }
+  /**
+   * Delete a meta entry
+   */
+  async deleteEntry(metadataId, entryId) {
+    return this.request({
+      method: "DELETE",
+      url: `${this.path}/${metadataId}/entries/${entryId}`
+    });
+  }
+  /**
+   * Get entry by ID
+   */
+  async getEntryById(metadataId, entryId) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${metadataId}/entries/${entryId}`
+    });
+  }
+};
+
+// src/resources/admin/seo.ts
+var SEOResource = class extends BaseResource {
+  constructor(httpClient, path = "/api/admin/seo") {
+    super(httpClient);
+    this.path = path;
+  }
+  /**
+   * SEO doğrulama durumunu getirir (Validates listesi)
+   */
+  async getValidation() {
+    return this.request({ method: "GET", url: this.path });
+  }
+  /**
+   * Site ayarlarını getirir (UtilityController üzerinden)
+   */
+  async getSettings(languageCode = "en") {
+    return this.request({
+      method: "GET",
+      url: "/api/settings",
+      params: { languageCode }
+    });
+  }
+  /**
+   * Site ayarlarını günceller (UtilityController üzerinden)
+   */
+  async updateSettings(data) {
+    return this.request({ method: "POST", url: "/api/settings/update", data });
+  }
+};
+
+// src/resources/admin/store.ts
+var storeColumns = (...cols) => cols;
+var StoreResource = class extends CrudResource {
+  constructor(httpClient, path = "/api/admin/store") {
+    super(httpClient, path);
+  }
+  async getStore() {
+    return this.request({
+      method: "GET",
+      url: this.path
+    });
+  }
+  async getStoreGraph(body) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/graph`,
+      data: body
+    });
+  }
+  async updateStore(data) {
+    return this.request({
+      method: "PUT",
+      url: this.path,
+      data
+    });
+  }
+};
+
+// src/resources/admin/content.ts
+var contentColumns = (...cols) => cols;
+var ContentResource = class extends CrudResource {
+  constructor(httpClient, path = "/api/admin/contents") {
+    super(httpClient, path);
+  }
+  /** @deprecated Use edit(id, data) instead */
+  async updateById(id, data) {
+    return this.edit(id, data);
+  }
+  async getLinking(id) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${id}/linking`
+    });
+  }
+  async updateLinking(id, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${id}/linking`,
+      data
+    });
+  }
+  async getTranslate(id, source) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${id}/translate`,
+      params: { source }
+    });
+  }
+  async updateTranslate(id, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${id}/translate`,
+      data
+    });
+  }
+  async getVariants(id) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${id}/variants`
+    });
+  }
+  async updateVariants(id, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${id}/variants`,
+      data
+    });
+  }
+  async updateCustomData(id, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${id}/customdata`,
+      data
+    });
+  }
+  async getImportSchema() {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/import`
+    });
+  }
+  async bulkImport(data) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/import`,
+      data
+    });
+  }
+  async createMockData() {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/mock`
+    });
+  }
+};
+
+// src/resources/admin/collection.ts
+var collectionColumns = (...cols) => cols;
+var CollectionResource = class extends CrudResource {
+  constructor(httpClient, path = "/api/admin/collections") {
+    super(httpClient, path);
+  }
+  /** @deprecated Use edit(id, data) instead */
+  async updateById(id, data) {
+    return this.edit(id, data);
+  }
+  async getTranslate(id, source) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${id}/translate`,
+      params: { source }
+    });
+  }
+  async updateTranslate(id, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${id}/translate`,
+      data
+    });
+  }
+  async bulkImport(data) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/import`,
+      data
+    });
+  }
+};
+
+// src/resources/admin/navigation.ts
+var navigationColumns = (...cols) => cols;
+var NavigationResource = class extends CrudResource {
+  constructor(httpClient, path = "/api/admin/navigations") {
+    super(httpClient, path);
+  }
+  async getItems(navigationId) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${navigationId}/items`
+    });
+  }
+  async createItem(navigationId, data) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/${navigationId}/items`,
+      data
+    });
+  }
+  async updateItemsOrder(navigationId, items) {
+    return this.request({
+      method: "PATCH",
+      url: `${this.path}/${navigationId}/items`,
+      data: { items }
+    });
+  }
+  async updateItem(itemId, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/items/${itemId}`,
+      data
+    });
+  }
+  async getItemById(itemId) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/items/${itemId}`
+    });
+  }
+  async deleteItem(itemId) {
+    return this.request({
+      method: "DELETE",
+      url: `${this.path}/items/${itemId}`
+    });
+  }
+  async getTranslate(id, source) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${id}/translate`,
+      params: { source }
+    });
+  }
+  async updateTranslate(id, data) {
+    return this.request({
+      method: "PUT",
+      url: `${this.path}/${id}/translate`,
+      data
+    });
+  }
+};
+
+// src/resources/admin/media.ts
+var MediaResource = class extends BaseResource {
+  path = "/api/admin/media";
+  constructor(httpClient, path) {
+    super(httpClient);
+    if (path) this.path = path;
+  }
+  async getAll() {
+    return this.request({
+      method: "GET",
+      url: this.path
+    });
+  }
+  async create(data) {
+    return this.request({
+      method: "POST",
+      url: this.path,
+      data
+    });
+  }
+  async getById(mediaId) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${mediaId}`
+    });
+  }
+  /** Cloudflare-style: delete resource by ID */
+  async deleteById(mediaId) {
+    await this.request({
+      method: "DELETE",
+      url: `${this.path}/${mediaId}`
+    });
+  }
+  /** @deprecated Use deleteById(id) instead */
+  async delete(mediaId) {
+    await this.deleteById(mediaId);
+    return { data: null };
+  }
+};
+
+// src/resources/admin/language.ts
+var languageColumns = (...cols) => cols;
+var LanguageResource = class extends CrudResource {
+  constructor(httpClient, path = "/api/admin/languages") {
+    super(httpClient, path);
+  }
+  /**
+   * Get default language
+   */
+  async getDefault() {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/default-language`
+    });
+  }
+};
+
+// src/resources/admin/auth.ts
+var AuthResource = class extends BaseResource {
+  path = "/api/auth";
+  constructor(httpClient, path) {
+    super(httpClient);
+    if (path) this.path = path;
+  }
+  /**
+   * Email/Password ile giriş (Web - Cookie based)
+   */
+  async signInEmail(input) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/sign-in/email`,
+      data: input
+    });
+  }
+  /**
+   * Email/Password ile kayıt (Web - Cookie based)
+   */
+  async signUpEmail(input) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/sign-up/email`,
+      data: input
+    });
+  }
+  /**
+   * Mobil Uygulama Login (Token based)
+   * Bu metod, SDK kullanımı için en uygun olanıdır.
+   */
+  async mobileLogin(input) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/mobile/login`,
+      data: input
+    });
+  }
+  /**
+   * Mobil Token Yenileme
+   */
+  async mobileRefresh(token) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/mobile/refresh`,
+      data: { token }
+    });
+  }
+  /**
+   * Mobil Token Doğrulama
+   */
+  async mobileValidate() {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/mobile/validate`
+    });
+  }
+  /**
+   * Mevcut session bilgisini getirir
+   */
+  async getSession() {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/session`
+    });
+  }
+  /**
+   * Çıkış yap (Backend: POST /api/auth/logout)
+   */
+  async signOut() {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/sign-out`
+    });
+  }
+  /**
+   * Logout - invalidate session on backend (Backend: POST /api/auth/logout)
+   */
+  async logout() {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/logout`
+    });
+  }
+};
+
+// src/resources/admin/google.ts
+var GoogleResource = class extends BaseResource {
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  async getSites() {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/google"
+    });
+  }
+  async getAnalytics(propertyId) {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/google/analytics",
+      params: { propertyId }
+    });
+  }
+  async updateSitemap(siteUrl, sitemapUrl) {
+    return this.request({
+      method: "PUT",
+      url: "/api/admin/google/webconsole",
+      data: { siteUrl, sitemapUrl }
+    });
+  }
+  async getPerformance(siteUrl, startDate, endDate) {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/google/performance",
+      params: { siteUrl, startDate, endDate }
+    });
+  }
+  async connectGoogleAnalytics(data) {
+    return this.request({
+      method: "POST",
+      url: "/api/admin/google/connect",
+      data
+    });
+  }
+  async getAnalyticsAccount() {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/google/analytics/account"
+    });
+  }
+  async getAnalyticsAccountDetails(acc) {
+    return this.request({
+      method: "GET",
+      url: `/api/admin/google/analytics/account/${acc}`
+    });
+  }
+  async getDetailedAnalytics(acc, propertyId, reportType) {
+    return this.request({
+      method: "POST",
+      url: `/api/admin/google/analytics/account/${acc}`,
+      data: { propertyId, reportType }
+    });
+  }
+};
+
+// src/resources/admin/cloudflare.ts
+var CloudflareResource = class extends BaseResource {
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  async getAccounts() {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/cloudflare"
+    });
+  }
+  async getZones(verified) {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/cloudflare/zones",
+      params: { verified }
+    });
+  }
+  async getZonesSelect() {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/cloudflare/zones/select"
+    });
+  }
+  async createZone(domain, openProviderData) {
+    return this.request({
+      method: "POST",
+      url: "/api/admin/cloudflare/zones/new",
+      data: { domain, ...openProviderData && { openProviderData } }
+    });
+  }
+  async getZoneById(zoneId) {
+    return this.request({
+      method: "GET",
+      url: `/api/admin/cloudflare/zones/${zoneId}`
+    });
+  }
+  async createDnsRecord(zoneId, data) {
+    return this.request({
+      method: "POST",
+      url: `/api/admin/cloudflare/zones/${zoneId}`,
+      data
+    });
+  }
+  async updateDnsRecord(zoneId, data) {
+    return this.request({
+      method: "PUT",
+      url: `/api/admin/cloudflare/zones/${zoneId}`,
+      data
+    });
+  }
+  async deleteDnsRecord(zoneId, dnsId) {
+    return this.request({
+      method: "DELETE",
+      url: `/api/admin/cloudflare/zones/${zoneId}`,
+      data: { dnsId }
+    });
+  }
+  async submitSitemap() {
+    return this.request({
+      method: "POST",
+      url: "/api/admin/cloudflare/zones/sitemap"
+    });
+  }
+  async checkZone(zoneId) {
+    return this.request({
+      method: "GET",
+      url: `/api/admin/cloudflare/zones/${zoneId}/check`
+    });
+  }
+  async getAccountById(accountId) {
+    return this.request({
+      method: "GET",
+      url: `/api/admin/cloudflare/accounts/${accountId}`
+    });
+  }
+  async fixWebmasterVerify() {
+    return this.request({
+      method: "POST",
+      url: "/api/admin/cloudflare/zones/fix-webmaster-verify"
+    });
+  }
+  async searchDomains(query) {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/cloudflare/zones/buy",
+      params: { q: query }
+    });
+  }
+  async buyDomain(data) {
+    return this.request({
+      method: "POST",
+      url: "/api/admin/cloudflare/zones/buy",
+      data
+    });
+  }
+};
+
+// src/resources/admin/review.ts
+var ReviewResource = class extends CrudResource {
+  constructor(httpClient) {
+    super(httpClient, "/api/admin/contents/reviews");
+  }
+  async getReviews(params) {
+    return this.request({
+      method: "GET",
+      url: this.path,
+      params
+    });
+  }
+};
+
+// src/resources/admin/custom-data.ts
+var CustomDataResource = class extends BaseResource {
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  async getAll(scope) {
+    return this.request({
+      method: "GET",
+      url: `/api/admin/custom_data/${scope}`
+    });
+  }
+  async create(scope, data) {
+    return this.request({
+      method: "POST",
+      url: `/api/admin/custom_data/${scope}`,
+      data
+    });
+  }
+  async getById(scope, id) {
+    return this.request({
+      method: "GET",
+      url: `/api/admin/custom_data/${scope}/${id}`
+    });
+  }
+  async update(scope, id, data) {
+    return this.request({
+      method: "PUT",
+      url: `/api/admin/custom_data/${scope}/${id}`,
+      data
+    });
+  }
+  async delete(scope, id) {
+    return this.request({
+      method: "DELETE",
+      url: `/api/admin/custom_data/${scope}/${id}`
+    });
+  }
+  async getForm(scope, type) {
+    return this.request({
+      method: "GET",
+      url: `/api/admin/custom_data/form/${scope}/${type}`
+    });
+  }
+  async getFormVariants(scope, categoryId) {
+    return this.request({
+      method: "GET",
+      url: `/api/admin/custom_data/form/${scope}/variants/${categoryId}`
+    });
+  }
+};
+
+// src/resources/admin/project.ts
+var projectColumns = (...cols) => cols;
+var ProjectResource = class extends CrudResource {
+  constructor(httpClient) {
+    super(httpClient, "/api/admin/projects");
+  }
+};
+
+// src/resources/admin/sector.ts
+var sectorColumns = (...cols) => cols;
+var SectorResource = class extends CrudResource {
+  constructor(httpClient) {
+    super(httpClient, "/api/admin/sectors");
+  }
+};
+
+// src/resources/admin/webmail.ts
+var WebmailResource = class extends BaseResource {
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  async getWebmail() {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/webmail"
+    });
+  }
+  async getMailboxes(email) {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/webmail/mail",
+      params: { email }
+    });
+  }
+  async createMailbox(data) {
+    return this.request({
+      method: "POST",
+      url: "/api/admin/webmail/mail",
+      data
+    });
+  }
+  async updateMailbox(data) {
+    return this.request({
+      method: "PUT",
+      url: "/api/admin/webmail/mail",
+      data
+    });
+  }
+  async deleteMailbox(email) {
+    return this.request({
+      method: "DELETE",
+      url: "/api/admin/webmail/mail",
+      params: { email }
+    });
+  }
+};
+
+// src/resources/admin/subscription.ts
+var SubscriptionResource = class extends BaseResource {
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  async getPackages(category) {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/subscribe",
+      params: { category }
+    });
+  }
+  async subscribe(data) {
+    return this.request({
+      method: "POST",
+      url: "/api/admin/subscribe",
+      data
+    });
+  }
+  async getCurrentSubscription() {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/subscribe/me"
+    });
+  }
+  async cancelSubscription(id) {
+    return this.request({
+      method: "POST",
+      url: "/api/admin/subscribe/me/cancel",
+      data: { id }
+    });
+  }
+  async upgradeSubscription(data) {
+    return this.request({
+      method: "POST",
+      url: "/api/admin/subscribe/upgrade",
+      data
+    });
+  }
+  async retrySubscription(data) {
+    return this.request({
+      method: "POST",
+      url: "/api/admin/subscribe/retry",
+      data
+    });
+  }
+  async getBilling() {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/subscribe/billing"
+    });
+  }
+  async validateSubscription() {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/subscribe/validate"
+    });
+  }
+};
+
+// src/resources/admin/purchase.ts
+var PurchaseResource = class extends BaseResource {
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  async getPurchases() {
+    return this.request({
+      method: "GET",
+      url: "/api/admin/purchase"
+    });
+  }
+  async createPurchase(data) {
+    return this.request({
+      method: "POST",
+      url: "/api/admin/purchase",
+      data
+    });
+  }
+};
+
+// src/resources/frontstore/index.ts
+var frontstore_exports = {};
+__export(frontstore_exports, {
+  CollectionResource: () => CollectionResource2,
+  ContentResource: () => ContentResource2,
+  ContentTypesResource: () => ContentTypesResource,
+  FavoriteResource: () => FavoriteResource,
+  LanguageResource: () => LanguageResource2,
+  MediaResource: () => MediaResource2,
+  NavigationResource: () => NavigationResource2,
+  PageLayoutResource: () => PageLayoutResource,
+  ReviewResource: () => ReviewResource2,
+  ShopResource: () => ShopResource,
+  SlugsResource: () => SlugsResource,
+  StoreResource: () => StoreResource2,
+  UserResource: () => UserResource,
+  UtilityResource: () => UtilityResource,
+  collectionColumns: () => collectionColumns2,
+  contentColumns: () => contentColumns2
+});
+
+// src/resources/frontstore/store.ts
+var StoreResource2 = class extends CrudResource {
+  constructor(httpClient, path = "/api/store") {
+    super(httpClient, path);
+  }
+  async getBySlug(slug) {
+    const response = await this.findMany({ where: { slug, isActive: true }, take: 1 });
+    return response.data.length > 0 ? response.data[0] : null;
+  }
+};
+
+// src/resources/frontstore/content.ts
+var contentColumns2 = (...cols) => cols;
+var ContentResource2 = class extends CrudResource {
+  constructor(httpClient, path = "/api/content") {
+    super(httpClient, path);
+  }
+  async getByCollection(collectionId) {
+    return this.list({
+      filter: { collectionId, isActive: true },
+      sort: "order:asc",
+      paginate: { page: 1, limit: 50 }
+    });
+  }
+  async getByScope(scope, query) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/${scope}`,
+      data: query || {}
+    });
+  }
+  async getByIdByScope(scope, id, query) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/${scope}/${id}`,
+      data: query || {}
+    });
+  }
+};
+
+// src/resources/frontstore/collection.ts
+var collectionColumns2 = (...cols) => cols;
+var CollectionResource2 = class extends CrudResource {
+  constructor(httpClient, path = "/api/collections") {
+    super(httpClient, path);
+  }
+  async getByStore(storeId) {
+    return this.list({
+      filter: { storeId, isActive: true },
+      sort: "order:asc"
+    });
+  }
+  async getByScope(scope, query) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/${scope}`,
+      data: query || {}
+    });
+  }
+  async getFilters(scope, filters, language = "en-gb", parentId) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/${scope}/filters`,
+      params: { language },
+      data: { filters, parentId }
+    });
+  }
+};
+
+// src/resources/frontstore/navigation.ts
+var NavigationResource2 = class extends CrudResource {
+  constructor(httpClient, path = "/api/navigation") {
+    super(httpClient, path);
+  }
+  async getItems(navigationId) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${navigationId}/items`
+    });
+  }
+};
+
+// src/resources/frontstore/media.ts
+var MediaResource2 = class extends CrudResource {
+  constructor(httpClient, path = "/api/media") {
+    super(httpClient, path);
+  }
+};
+
+// src/resources/frontstore/user.ts
+var UserResource = class extends CrudResource {
+  constructor(httpClient, path = "/api/user") {
+    super(httpClient, path);
+  }
+  async me() {
+    return this.request({ method: "GET", url: `${this.path}/me` });
+  }
+};
+
+// src/resources/frontstore/shop.ts
+var ShopResource = class extends BaseResource {
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  // Products
+  async getProducts(params) {
+    return this.request({
+      method: "GET",
+      url: "/api/shop/products",
+      params
+    });
+  }
+  async getProduct(id) {
+    return this.request({
+      method: "GET",
+      url: `/api/shop/products/${id}`
+    });
+  }
+  // Cart
+  async createCart(data) {
+    return this.request({
+      method: "POST",
+      url: "/api/shop/cart",
+      data
+    });
+  }
+  async getCart(id) {
+    return this.request({
+      method: "GET",
+      url: `/api/shop/cart/${id}`
+    });
+  }
+  async updateCart(id, data) {
+    return this.request({
+      method: "POST",
+      url: `/api/shop/cart/${id}`,
+      data
+    });
+  }
+  async addLineItem(cartId, data) {
+    return this.request({
+      method: "POST",
+      url: `/api/shop/cart/${cartId}/line-items`,
+      data
+    });
+  }
+  async updateLineItem(cartId, lineId, data) {
+    return this.request({
+      method: "POST",
+      url: `/api/shop/cart/${cartId}/line-items/${lineId}`,
+      data
+    });
+  }
+  async removeLineItem(cartId, lineId) {
+    return this.request({
+      method: "DELETE",
+      url: `/api/shop/cart/${cartId}/line-items/${lineId}`
+    });
+  }
+  async completeCart(cartId) {
+    return this.request({
+      method: "POST",
+      url: `/api/shop/cart/${cartId}/complete`
+    });
+  }
+  // Orders
+  async getMyOrders(params) {
+    return this.request({
+      method: "GET",
+      url: "/api/shop/orders/me",
+      params
+    });
+  }
+  async getOrder(id) {
+    return this.request({
+      method: "GET",
+      url: `/api/shop/orders/${id}`
+    });
+  }
+  // Checkout & Card Storage
+  async createPaymentLink(data) {
+    return this.request({
+      method: "POST",
+      url: "/api/shop/checkout/payment",
+      data
+    });
+  }
+  async handlePaymentCallback(data) {
+    return this.request({
+      method: "POST",
+      url: "/api/shop/checkout/callback",
+      data
+    });
+  }
+  async getInstallments(data) {
+    return this.request({
+      method: "POST",
+      url: "/api/shop/checkout/payment/installment",
+      data
+    });
+  }
+  async getCards() {
+    return this.request({
+      method: "GET",
+      url: "/api/shop/checkout/card-storage"
+    });
+  }
+  async saveCard(data) {
+    return this.request({
+      method: "POST",
+      url: "/api/shop/checkout/card-storage",
+      data
+    });
+  }
+  async deleteCard(cardToken) {
+    return this.request({
+      method: "DELETE",
+      url: "/api/shop/checkout/card-storage",
+      data: { cardToken }
+    });
+  }
+};
+
+// src/resources/frontstore/utility.ts
+var UtilityResource = class extends BaseResource {
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  async search(query, language = "en") {
+    return this.request({
+      method: "GET",
+      url: "/api/search",
+      params: { q: query, lang: language }
+    });
+  }
+  async getRfqs(userId) {
+    return this.request({
+      method: "GET",
+      url: "/api/rfq",
+      headers: { "x-user-id": userId }
+    });
+  }
+  async getRfqById(userId, id) {
+    return this.request({
+      method: "GET",
+      url: `/api/rfq/${id}`,
+      headers: { "x-user-id": userId }
+    });
+  }
+  async createRfq(userId, data) {
+    return this.request({
+      method: "POST",
+      url: "/api/rfq",
+      headers: { "x-user-id": userId },
+      data
+    });
+  }
+  async getSettings(languageCode = "en") {
+    return this.request({
+      method: "GET",
+      url: "/api/settings",
+      params: { languageCode }
+    });
+  }
+  async updateSettings(id, language, data) {
+    return this.request({
+      method: "POST",
+      url: "/api/settings/update",
+      data: { id, language, data }
+    });
+  }
+  async getRobots() {
+    return this.request({
+      method: "GET",
+      url: "/api/robots"
+    });
+  }
+  async getSitemap() {
+    return this.request({
+      method: "GET",
+      url: "/api/sitemap"
+    });
+  }
+  async getSitemapPart(scope, part, language = "en") {
+    return this.request({
+      method: "GET",
+      url: `/api/sitemap/${scope}/${part}`,
+      params: { language }
+    });
+  }
+};
+
+// src/resources/frontstore/favorite.ts
+var FavoriteResource = class extends BaseResource {
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  async getFavorites(userId, language = "en") {
+    return this.request({
+      method: "GET",
+      url: "/api/favorites",
+      headers: { "x-user-id": userId },
+      params: { language }
+    });
+  }
+  async addFavorite(userId, contentId) {
+    return this.request({
+      method: "POST",
+      url: "/api/favorites",
+      headers: { "x-user-id": userId },
+      data: { id: contentId }
+    });
+  }
+  async removeFavorite(userId, id, contentId) {
+    return this.request({
+      method: "DELETE",
+      url: "/api/favorites",
+      headers: { "x-user-id": userId },
+      params: id ? { id } : contentId ? { contentId } : {}
+    });
+  }
+};
+
+// src/resources/frontstore/language.ts
+var LanguageResource2 = class extends BaseResource {
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  async getLanguages(includeInactive = false) {
+    return this.request({
+      method: "GET",
+      url: "/api/languages",
+      params: { includeInactive: includeInactive.toString() }
+    });
+  }
+};
+
+// src/resources/frontstore/layout.ts
+var PageLayoutResource = class extends CrudResource {
+  constructor(httpClient) {
+    super(httpClient, "/api/layouts");
+  }
+  async getById(id, contentId, preview = false) {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${id}`,
+      params: { contentId, preview }
+    });
+  }
+};
+
+// src/resources/frontstore/content-types.ts
+var ContentTypesResource = class extends CrudResource {
+  constructor(httpClient) {
+    super(httpClient, "/api/content-types");
+  }
+};
+
+// src/resources/frontstore/review.ts
+var ReviewResource2 = class extends BaseResource {
+  path = "/api/content/reviews";
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  async getReviews(slug, page = 1, limit = 10, language = "en") {
+    return this.request({
+      method: "GET",
+      url: `${this.path}/${slug}`,
+      params: { page, limit, language }
+    });
+  }
+  async createReview(slug, userId, data) {
+    return this.request({
+      method: "POST",
+      url: `${this.path}/${slug}`,
+      headers: { "x-user-id": userId },
+      data
+    });
+  }
+};
+
+// src/resources/frontstore/slugs.ts
+var SlugsResource = class extends BaseResource {
+  path = "/api/slugs";
+  constructor(httpClient) {
+    super(httpClient);
+  }
+  /**
+   * Get store settings by origin
+   */
+  async getStore() {
+    return this.request({
+      method: "GET",
+      url: this.path
+    });
+  }
+  /**
+   * Get comprehensive page data based on slugs
+   */
+  async getPageData(dto) {
+    return this.request({
+      method: "POST",
+      url: this.path,
+      data: dto
+    });
+  }
+};
+
+// src/core/response.ts
+function unwrap(response, fallback) {
+  if (response == null) return fallback;
+  if (typeof response === "object" && "data" in response && response.data !== void 0) {
+    const data = response.data;
+    return data ?? fallback;
+  }
+  return response ?? fallback;
+}
+function unwrapList(response) {
+  const data = unwrap(response, []);
+  return Array.isArray(data) ? data : [];
+}
+function unwrapMeta(response) {
+  if (!response || typeof response !== "object") return void 0;
+  return response.meta;
+}
+
+// src/types/admin/index.ts
+var admin_exports2 = {};
+
+// src/types/frontstore/index.ts
+var frontstore_exports2 = {};
+
+// src/types/common/index.ts
+var common_exports = {};
+
+// src/types/schema/index.ts
+var schema_exports = {};
+__export(schema_exports, {
+  columns: () => columns
+});
+
+// src/types/schema/columns.ts
+function columns(...cols) {
+  return cols;
+}
+
+// src/index.ts
+var AdminNamespace = class {
+  vendors;
+  contents;
+  stores;
+  collections;
+  navigations;
+  layouts;
+  settings;
+  apiKeys;
+  media;
+  languages;
+  datasource;
+  metadata;
+  seo;
+  auth;
+  sections;
+  themes;
+  google;
+  cloudflare;
+  reviews;
+  customData;
+  projects;
+  sectors;
+  webmail;
+  subscriptions;
+  purchases;
+  constructor(client) {
+    this.vendors = new VendorResource(client.instance);
+    this.contents = new ContentResource(client.instance);
+    this.stores = new StoreResource(client.instance);
+    this.collections = new CollectionResource(client.instance);
+    this.navigations = new NavigationResource(client.instance);
+    this.layouts = new LayoutResource(client.instance);
+    this.settings = new SettingsResource(client.instance);
+    this.apiKeys = new ApiKeyResource(client.instance);
+    this.media = new MediaResource(client.instance);
+    this.languages = new LanguageResource(client.instance);
+    this.datasource = new DatasourceResource(client.instance);
+    this.metadata = new MetadataResource(client.instance);
+    this.seo = new SEOResource(client.instance);
+    this.auth = new AuthResource(client.instance);
+    this.sections = new SectionResource(client.instance);
+    this.themes = new ThemeResource(client.instance);
+    this.google = new GoogleResource(client.instance);
+    this.cloudflare = new CloudflareResource(client.instance);
+    this.reviews = new ReviewResource(client.instance);
+    this.customData = new CustomDataResource(client.instance);
+    this.projects = new ProjectResource(client.instance);
+    this.sectors = new SectorResource(client.instance);
+    this.webmail = new WebmailResource(client.instance);
+    this.subscriptions = new SubscriptionResource(client.instance);
+    this.purchases = new PurchaseResource(client.instance);
+  }
+};
+var FrontstoreNamespace = class {
+  store;
+  collection;
+  content;
+  navigation;
+  media;
+  user;
+  shop;
+  utility;
+  favorite;
+  language;
+  layouts;
+  contentTypes;
+  review;
+  slugs;
+  constructor(client) {
+    this.store = new StoreResource2(client.instance);
+    this.collection = new CollectionResource2(client.instance);
+    this.content = new ContentResource2(client.instance);
+    this.navigation = new NavigationResource2(client.instance);
+    this.media = new MediaResource2(client.instance);
+    this.user = new UserResource(client.instance);
+    this.shop = new ShopResource(client.instance);
+    this.utility = new UtilityResource(client.instance);
+    this.favorite = new FavoriteResource(client.instance);
+    this.language = new LanguageResource2(client.instance);
+    this.layouts = new PageLayoutResource(client.instance);
+    this.contentTypes = new ContentTypesResource(client.instance);
+    this.review = new ReviewResource2(client.instance);
+    this.slugs = new SlugsResource(client.instance);
+  }
+};
+var SalefonyApiSdk = class {
+  client;
+  /** Admin API Kaynakları */
+  admin;
+  /** Frontstore API Kaynakları */
+  frontstore;
+  // Root level access for convenience (matches frontstore)
+  store;
+  collection;
+  content;
+  user;
+  navigation;
+  media;
+  shop;
+  utility;
+  favorite;
+  language;
+  layouts;
+  contentTypes;
+  review;
+  slugs;
+  constructor(config) {
+    this.client = new ApiClient(config);
+    this.admin = new AdminNamespace(this.client);
+    this.frontstore = new FrontstoreNamespace(this.client);
+    this.store = this.frontstore.store;
+    this.collection = this.frontstore.collection;
+    this.content = this.frontstore.content;
+    this.navigation = this.frontstore.navigation;
+    this.media = this.frontstore.media;
+    this.user = this.frontstore.user;
+    this.shop = this.frontstore.shop;
+    this.utility = this.frontstore.utility;
+    this.favorite = this.frontstore.favorite;
+    this.language = this.frontstore.language;
+    this.layouts = this.frontstore.layouts;
+    this.contentTypes = this.frontstore.contentTypes;
+    this.review = this.frontstore.review;
+    this.slugs = this.frontstore.slugs;
+  }
+  /**
+   * Ekstra headerlar ekler (Method Chaining)
+   */
+  setHeaders(headers) {
+    this.client.setExtraHeaders(headers);
+    return this;
+  }
+  /**
+   * Bearer token ayarlar (Method Chaining)
+   */
+  setAuthToken(token) {
+    this.client.setAuthToken(token);
+    return this;
+  }
+  /**
+   * Vendor API anahtarı ayarlar (Method Chaining)
+   */
+  setVendorKey(key) {
+    this.client.setVendorKey(key);
+    return this;
+  }
+  /**
+   * Bearer token temizler (Method Chaining)
+   */
+  logout() {
+    this.client.clearAuth();
+    return this;
+  }
+  /**
+   * API Client instance'ını döner
+   */
+  get apiClient() {
+    return this.client;
+  }
+};
+var createSDK = (config) => new SalefonyApiSdk(config);
+function getEnv() {
+  if (typeof globalThis === "undefined") return void 0;
+  try {
+    const g = globalThis;
+    return g.process?.env;
+  } catch {
+    return void 0;
+  }
+}
+function createSDKFromEnv(config = {}) {
+  const env = getEnv();
+  const baseUrl = config.baseUrl ?? env?.NEXT_PUBLIC_BACKEND_API_URL ?? env?.BACKEND_API_URL ?? "http://localhost:3031";
+  const debug = config.debug ?? env?.NODE_ENV === "development";
+  return createSDK({
+    baseUrl,
+    debug,
+    ...config
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdminResources,
+  AdminTypes,
+  ApiClient,
+  BaseResource,
+  CommonTypes,
+  CrudResource,
+  FrontstoreResources,
+  FrontstoreTypes,
+  QueryBuilder,
+  SalefonyApiSdk,
+  SalefonyAuthError,
+  SalefonyError,
+  SalefonyNotFoundError,
+  SalefonyValidationError,
+  SchemaTypes,
+  apiKeyColumns,
+  collectionColumns,
+  columns,
+  contentColumns,
+  createSDK,
+  createSDKFromEnv,
+  datasourceColumns,
+  languageColumns,
+  layoutColumns,
+  metadataColumns,
+  navigationColumns,
+  projectColumns,
+  sectionColumns,
+  sectorColumns,
+  storeColumns,
+  unwrap,
+  unwrapList,
+  unwrapMeta,
+  vendorColumns
+});